smolheed

Struct EnvOpenOptions

Source 
pub struct EnvOpenOptions { /* private fields */ }

Implementations§

Source§

impl EnvOpenOptions

Source

pub fn new() -> EnvOpenOptions

Examples found in repository?
examples/cursor-append.rs (line 15)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("cursor-append.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let first = env.create_database(Some("first"))?;
21    let second = env.create_database(Some("second"))?;
22
23    let mut wtxn = env.write_txn()?;
24
25    // We fill the first database with entries.
26    first.put(&mut wtxn, b"I am here", b"to test things")?;
27    first.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
28
29    // We try to append ordered entries in the second database.
30    let mut iter = second.iter_mut(&mut wtxn)?;
31
32    unsafe { iter.append(b"aaaa", b"lol")? };
33    unsafe { iter.append(b"abcd", b"lol")? };
34    unsafe { iter.append(b"bcde", b"lol")? };
35
36    drop(iter);
37
38    wtxn.commit()?;
39
40    Ok(())
41}
More examples
Hide additional examples
examples/multi-env.rs (line 12)
7fn main() -> Result<(), Box<dyn Error>> {
8    let env1_path = Path::new("target").join("env1.mdb");
9    let env2_path = Path::new("target").join("env2.mdb");
10
11    fs::create_dir_all(&env1_path)?;
12    let env1 = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(env1_path)?;
16
17    fs::create_dir_all(&env2_path)?;
18    let env2 = EnvOpenOptions::new()
19        .map_size(10 * 1024 * 1024) // 10MB
20        .max_dbs(3000)
21        .open(env2_path)?;
22
23    let db1 = env1.create_database(Some("hello"))?;
24    let db2 = env2.create_database(Some("hello"))?;
25
26    // clear db
27    let mut wtxn = env1.write_txn()?;
28    db1.clear(&mut wtxn)?;
29    wtxn.commit()?;
30
31    // clear db
32    let mut wtxn = env2.write_txn()?;
33    db2.clear(&mut wtxn)?;
34    wtxn.commit()?;
35
36    // -----
37
38    let mut wtxn1 = env1.write_txn()?;
39
40    db1.put(&mut wtxn1, b"what", &[4, 5][..])?;
41    db1.get(&wtxn1, b"what")?;
42    wtxn1.commit()?;
43
44    let rtxn2 = env2.read_txn()?;
45    let ret = db2.last(&rtxn2)?;
46    assert_eq!(ret, None);
47
48    Ok(())
49}
examples/clear-database.rs (line 15)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("clear-database.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let db = env.create_database(Some("first"))?;
21    let mut wtxn = env.write_txn()?;
22
23    // We fill the db database with entries.
24    db.put(&mut wtxn, b"I am here", b"to test things")?;
25    db.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
26
27    wtxn.commit()?;
28
29    let mut wtxn = env.write_txn()?;
30    db.clear(&mut wtxn)?;
31    db.put(&mut wtxn, b"And I come back", b"to test things")?;
32
33    let mut iter = db.iter(&wtxn)?;
34    assert_eq!(
35        iter.next().transpose()?,
36        Some((&b"And I come back"[..], &b"to test things"[..]))
37    );
38    assert_eq!(iter.next().transpose()?, None);
39
40    drop(iter);
41    wtxn.commit()?;
42
43    let rtxn = env.read_txn()?;
44    let mut iter = db.iter(&rtxn)?;
45    assert_eq!(
46        iter.next().transpose()?,
47        Some((&b"And I come back"[..], &b"to test things"[..]))
48    );
49    assert_eq!(iter.next().transpose()?, None);
50
51    Ok(())
52}
examples/nested.rs (line 12)
7fn main() -> Result<(), Box<dyn Error>> {
8    let path = Path::new("target").join("heed.mdb");
9
10    fs::create_dir_all(&path)?;
11
12    let env = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(path)?;
16
17    // here the key will be an str and the data will be a slice of u8
18    let db = env.create_database(None)?;
19
20    // clear db
21    let mut wtxn = env.write_txn()?;
22    db.clear(&mut wtxn)?;
23    wtxn.commit()?;
24
25    // -----
26
27    let mut wtxn = env.write_txn()?;
28    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
29
30    db.put(&mut nwtxn, b"what", &[4, 5][..])?;
31    let ret = db.get(&nwtxn, b"what")?;
32    println!("nested(1) \"what\": {:?}", ret);
33
34    println!("nested(1) abort");
35    nwtxn.abort()?;
36
37    let ret = db.get(&wtxn, b"what")?;
38    println!("parent \"what\": {:?}", ret);
39
40    // ------
41    println!();
42
43    // also try with multiple levels of nesting
44    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
45    let mut nnwtxn = env.nested_write_txn(&mut nwtxn)?;
46
47    db.put(&mut nnwtxn, b"humm...", &[6, 7][..])?;
48    let ret = db.get(&nnwtxn, b"humm...")?;
49    println!("nested(2) \"humm...\": {:?}", ret);
50
51    println!("nested(2) commit");
52    nnwtxn.commit()?;
53    nwtxn.commit()?;
54
55    let ret = db.get(&wtxn, b"humm...")?;
56    println!("parent \"humm...\": {:?}", ret);
57
58    db.put(&mut wtxn, b"hello", &[2, 3][..])?;
59
60    let ret = db.get(&wtxn, b"hello")?;
61    println!("parent \"hello\": {:?}", ret);
62
63    println!("parent commit");
64    wtxn.commit()?;
65
66    // ------
67    println!();
68
69    let rtxn = env.read_txn()?;
70
71    let ret = db.get(&rtxn, b"hello")?;
72    println!("parent (reader) \"hello\": {:?}", ret);
73
74    let ret = db.get(&rtxn, b"humm...")?;
75    println!("parent (reader) \"humm...\": {:?}", ret);
76
77    Ok(())
78}
Source

pub fn map_size(&mut self, size: usize) -> &mut Self

Examples found in repository?
examples/cursor-append.rs (line 16)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("cursor-append.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let first = env.create_database(Some("first"))?;
21    let second = env.create_database(Some("second"))?;
22
23    let mut wtxn = env.write_txn()?;
24
25    // We fill the first database with entries.
26    first.put(&mut wtxn, b"I am here", b"to test things")?;
27    first.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
28
29    // We try to append ordered entries in the second database.
30    let mut iter = second.iter_mut(&mut wtxn)?;
31
32    unsafe { iter.append(b"aaaa", b"lol")? };
33    unsafe { iter.append(b"abcd", b"lol")? };
34    unsafe { iter.append(b"bcde", b"lol")? };
35
36    drop(iter);
37
38    wtxn.commit()?;
39
40    Ok(())
41}
More examples
Hide additional examples
examples/multi-env.rs (line 13)
7fn main() -> Result<(), Box<dyn Error>> {
8    let env1_path = Path::new("target").join("env1.mdb");
9    let env2_path = Path::new("target").join("env2.mdb");
10
11    fs::create_dir_all(&env1_path)?;
12    let env1 = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(env1_path)?;
16
17    fs::create_dir_all(&env2_path)?;
18    let env2 = EnvOpenOptions::new()
19        .map_size(10 * 1024 * 1024) // 10MB
20        .max_dbs(3000)
21        .open(env2_path)?;
22
23    let db1 = env1.create_database(Some("hello"))?;
24    let db2 = env2.create_database(Some("hello"))?;
25
26    // clear db
27    let mut wtxn = env1.write_txn()?;
28    db1.clear(&mut wtxn)?;
29    wtxn.commit()?;
30
31    // clear db
32    let mut wtxn = env2.write_txn()?;
33    db2.clear(&mut wtxn)?;
34    wtxn.commit()?;
35
36    // -----
37
38    let mut wtxn1 = env1.write_txn()?;
39
40    db1.put(&mut wtxn1, b"what", &[4, 5][..])?;
41    db1.get(&wtxn1, b"what")?;
42    wtxn1.commit()?;
43
44    let rtxn2 = env2.read_txn()?;
45    let ret = db2.last(&rtxn2)?;
46    assert_eq!(ret, None);
47
48    Ok(())
49}
examples/clear-database.rs (line 16)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("clear-database.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let db = env.create_database(Some("first"))?;
21    let mut wtxn = env.write_txn()?;
22
23    // We fill the db database with entries.
24    db.put(&mut wtxn, b"I am here", b"to test things")?;
25    db.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
26
27    wtxn.commit()?;
28
29    let mut wtxn = env.write_txn()?;
30    db.clear(&mut wtxn)?;
31    db.put(&mut wtxn, b"And I come back", b"to test things")?;
32
33    let mut iter = db.iter(&wtxn)?;
34    assert_eq!(
35        iter.next().transpose()?,
36        Some((&b"And I come back"[..], &b"to test things"[..]))
37    );
38    assert_eq!(iter.next().transpose()?, None);
39
40    drop(iter);
41    wtxn.commit()?;
42
43    let rtxn = env.read_txn()?;
44    let mut iter = db.iter(&rtxn)?;
45    assert_eq!(
46        iter.next().transpose()?,
47        Some((&b"And I come back"[..], &b"to test things"[..]))
48    );
49    assert_eq!(iter.next().transpose()?, None);
50
51    Ok(())
52}
examples/nested.rs (line 13)
7fn main() -> Result<(), Box<dyn Error>> {
8    let path = Path::new("target").join("heed.mdb");
9
10    fs::create_dir_all(&path)?;
11
12    let env = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(path)?;
16
17    // here the key will be an str and the data will be a slice of u8
18    let db = env.create_database(None)?;
19
20    // clear db
21    let mut wtxn = env.write_txn()?;
22    db.clear(&mut wtxn)?;
23    wtxn.commit()?;
24
25    // -----
26
27    let mut wtxn = env.write_txn()?;
28    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
29
30    db.put(&mut nwtxn, b"what", &[4, 5][..])?;
31    let ret = db.get(&nwtxn, b"what")?;
32    println!("nested(1) \"what\": {:?}", ret);
33
34    println!("nested(1) abort");
35    nwtxn.abort()?;
36
37    let ret = db.get(&wtxn, b"what")?;
38    println!("parent \"what\": {:?}", ret);
39
40    // ------
41    println!();
42
43    // also try with multiple levels of nesting
44    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
45    let mut nnwtxn = env.nested_write_txn(&mut nwtxn)?;
46
47    db.put(&mut nnwtxn, b"humm...", &[6, 7][..])?;
48    let ret = db.get(&nnwtxn, b"humm...")?;
49    println!("nested(2) \"humm...\": {:?}", ret);
50
51    println!("nested(2) commit");
52    nnwtxn.commit()?;
53    nwtxn.commit()?;
54
55    let ret = db.get(&wtxn, b"humm...")?;
56    println!("parent \"humm...\": {:?}", ret);
57
58    db.put(&mut wtxn, b"hello", &[2, 3][..])?;
59
60    let ret = db.get(&wtxn, b"hello")?;
61    println!("parent \"hello\": {:?}", ret);
62
63    println!("parent commit");
64    wtxn.commit()?;
65
66    // ------
67    println!();
68
69    let rtxn = env.read_txn()?;
70
71    let ret = db.get(&rtxn, b"hello")?;
72    println!("parent (reader) \"hello\": {:?}", ret);
73
74    let ret = db.get(&rtxn, b"humm...")?;
75    println!("parent (reader) \"humm...\": {:?}", ret);
76
77    Ok(())
78}
Source

pub fn max_readers(&mut self, readers: u32) -> &mut Self

Source

pub fn max_dbs(&mut self, dbs: u32) -> &mut Self

Examples found in repository?
examples/cursor-append.rs (line 17)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("cursor-append.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let first = env.create_database(Some("first"))?;
21    let second = env.create_database(Some("second"))?;
22
23    let mut wtxn = env.write_txn()?;
24
25    // We fill the first database with entries.
26    first.put(&mut wtxn, b"I am here", b"to test things")?;
27    first.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
28
29    // We try to append ordered entries in the second database.
30    let mut iter = second.iter_mut(&mut wtxn)?;
31
32    unsafe { iter.append(b"aaaa", b"lol")? };
33    unsafe { iter.append(b"abcd", b"lol")? };
34    unsafe { iter.append(b"bcde", b"lol")? };
35
36    drop(iter);
37
38    wtxn.commit()?;
39
40    Ok(())
41}
More examples
Hide additional examples
examples/multi-env.rs (line 14)
7fn main() -> Result<(), Box<dyn Error>> {
8    let env1_path = Path::new("target").join("env1.mdb");
9    let env2_path = Path::new("target").join("env2.mdb");
10
11    fs::create_dir_all(&env1_path)?;
12    let env1 = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(env1_path)?;
16
17    fs::create_dir_all(&env2_path)?;
18    let env2 = EnvOpenOptions::new()
19        .map_size(10 * 1024 * 1024) // 10MB
20        .max_dbs(3000)
21        .open(env2_path)?;
22
23    let db1 = env1.create_database(Some("hello"))?;
24    let db2 = env2.create_database(Some("hello"))?;
25
26    // clear db
27    let mut wtxn = env1.write_txn()?;
28    db1.clear(&mut wtxn)?;
29    wtxn.commit()?;
30
31    // clear db
32    let mut wtxn = env2.write_txn()?;
33    db2.clear(&mut wtxn)?;
34    wtxn.commit()?;
35
36    // -----
37
38    let mut wtxn1 = env1.write_txn()?;
39
40    db1.put(&mut wtxn1, b"what", &[4, 5][..])?;
41    db1.get(&wtxn1, b"what")?;
42    wtxn1.commit()?;
43
44    let rtxn2 = env2.read_txn()?;
45    let ret = db2.last(&rtxn2)?;
46    assert_eq!(ret, None);
47
48    Ok(())
49}
examples/clear-database.rs (line 17)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("clear-database.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let db = env.create_database(Some("first"))?;
21    let mut wtxn = env.write_txn()?;
22
23    // We fill the db database with entries.
24    db.put(&mut wtxn, b"I am here", b"to test things")?;
25    db.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
26
27    wtxn.commit()?;
28
29    let mut wtxn = env.write_txn()?;
30    db.clear(&mut wtxn)?;
31    db.put(&mut wtxn, b"And I come back", b"to test things")?;
32
33    let mut iter = db.iter(&wtxn)?;
34    assert_eq!(
35        iter.next().transpose()?,
36        Some((&b"And I come back"[..], &b"to test things"[..]))
37    );
38    assert_eq!(iter.next().transpose()?, None);
39
40    drop(iter);
41    wtxn.commit()?;
42
43    let rtxn = env.read_txn()?;
44    let mut iter = db.iter(&rtxn)?;
45    assert_eq!(
46        iter.next().transpose()?,
47        Some((&b"And I come back"[..], &b"to test things"[..]))
48    );
49    assert_eq!(iter.next().transpose()?, None);
50
51    Ok(())
52}
examples/nested.rs (line 14)
7fn main() -> Result<(), Box<dyn Error>> {
8    let path = Path::new("target").join("heed.mdb");
9
10    fs::create_dir_all(&path)?;
11
12    let env = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(path)?;
16
17    // here the key will be an str and the data will be a slice of u8
18    let db = env.create_database(None)?;
19
20    // clear db
21    let mut wtxn = env.write_txn()?;
22    db.clear(&mut wtxn)?;
23    wtxn.commit()?;
24
25    // -----
26
27    let mut wtxn = env.write_txn()?;
28    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
29
30    db.put(&mut nwtxn, b"what", &[4, 5][..])?;
31    let ret = db.get(&nwtxn, b"what")?;
32    println!("nested(1) \"what\": {:?}", ret);
33
34    println!("nested(1) abort");
35    nwtxn.abort()?;
36
37    let ret = db.get(&wtxn, b"what")?;
38    println!("parent \"what\": {:?}", ret);
39
40    // ------
41    println!();
42
43    // also try with multiple levels of nesting
44    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
45    let mut nnwtxn = env.nested_write_txn(&mut nwtxn)?;
46
47    db.put(&mut nnwtxn, b"humm...", &[6, 7][..])?;
48    let ret = db.get(&nnwtxn, b"humm...")?;
49    println!("nested(2) \"humm...\": {:?}", ret);
50
51    println!("nested(2) commit");
52    nnwtxn.commit()?;
53    nwtxn.commit()?;
54
55    let ret = db.get(&wtxn, b"humm...")?;
56    println!("parent \"humm...\": {:?}", ret);
57
58    db.put(&mut wtxn, b"hello", &[2, 3][..])?;
59
60    let ret = db.get(&wtxn, b"hello")?;
61    println!("parent \"hello\": {:?}", ret);
62
63    println!("parent commit");
64    wtxn.commit()?;
65
66    // ------
67    println!();
68
69    let rtxn = env.read_txn()?;
70
71    let ret = db.get(&rtxn, b"hello")?;
72    println!("parent (reader) \"hello\": {:?}", ret);
73
74    let ret = db.get(&rtxn, b"humm...")?;
75    println!("parent (reader) \"humm...\": {:?}", ret);
76
77    Ok(())
78}
Source

pub unsafe fn flag(&mut self, flag: Flags) -> &mut Self

Set one or more LMDB flags (see http://www.lmdb.tech/doc/group__mdb__env.html).

use std::fs;
use std::path::Path;
use smolheed::{EnvOpenOptions, Database};
use smolheed::flags::Flags;

fs::create_dir_all(Path::new("target").join("zerocopy.mdb"))?;
let mut env_builder = EnvOpenOptions::new();
unsafe {
    env_builder.flag(Flags::MdbNoTls);
    env_builder.flag(Flags::MdbNoMetaSync);
}
let env = env_builder.open(Path::new("target").join("zerocopy.mdb"))?;

// we will open the default unamed database
let db = env.create_database(None)?;

// opening a write transaction
let mut wtxn = env.write_txn()?;
db.put(&mut wtxn, "seven", 7_i32.to_be_bytes())?;
db.put(&mut wtxn, "zero", 0_i32.to_be_bytes())?;
db.put(&mut wtxn, "five", 5_i32.to_be_bytes())?;
db.put(&mut wtxn, "three", 3_i32.to_be_bytes())?;
wtxn.commit()?;

// Force the OS to flush the buffers (see Flags::MdbNoSync and Flags::MdbNoMetaSync).
env.force_sync();

// opening a read transaction
// to check if those values are now available
let mut rtxn = env.read_txn()?;

let ret = db.get(&rtxn, "zero")?;
assert_eq!(ret, Some(&0_i32.to_be_bytes()[..]));

let ret = db.get(&rtxn, "five")?;
assert_eq!(ret, Some(&5_i32.to_be_bytes()[..]));
Source

pub fn open<P: AsRef<Path>>(&self, path: P) -> Result<Env>

Examples found in repository?
examples/cursor-append.rs (line 18)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("cursor-append.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let first = env.create_database(Some("first"))?;
21    let second = env.create_database(Some("second"))?;
22
23    let mut wtxn = env.write_txn()?;
24
25    // We fill the first database with entries.
26    first.put(&mut wtxn, b"I am here", b"to test things")?;
27    first.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
28
29    // We try to append ordered entries in the second database.
30    let mut iter = second.iter_mut(&mut wtxn)?;
31
32    unsafe { iter.append(b"aaaa", b"lol")? };
33    unsafe { iter.append(b"abcd", b"lol")? };
34    unsafe { iter.append(b"bcde", b"lol")? };
35
36    drop(iter);
37
38    wtxn.commit()?;
39
40    Ok(())
41}
More examples
Hide additional examples
examples/multi-env.rs (line 15)
7fn main() -> Result<(), Box<dyn Error>> {
8    let env1_path = Path::new("target").join("env1.mdb");
9    let env2_path = Path::new("target").join("env2.mdb");
10
11    fs::create_dir_all(&env1_path)?;
12    let env1 = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(env1_path)?;
16
17    fs::create_dir_all(&env2_path)?;
18    let env2 = EnvOpenOptions::new()
19        .map_size(10 * 1024 * 1024) // 10MB
20        .max_dbs(3000)
21        .open(env2_path)?;
22
23    let db1 = env1.create_database(Some("hello"))?;
24    let db2 = env2.create_database(Some("hello"))?;
25
26    // clear db
27    let mut wtxn = env1.write_txn()?;
28    db1.clear(&mut wtxn)?;
29    wtxn.commit()?;
30
31    // clear db
32    let mut wtxn = env2.write_txn()?;
33    db2.clear(&mut wtxn)?;
34    wtxn.commit()?;
35
36    // -----
37
38    let mut wtxn1 = env1.write_txn()?;
39
40    db1.put(&mut wtxn1, b"what", &[4, 5][..])?;
41    db1.get(&wtxn1, b"what")?;
42    wtxn1.commit()?;
43
44    let rtxn2 = env2.read_txn()?;
45    let ret = db2.last(&rtxn2)?;
46    assert_eq!(ret, None);
47
48    Ok(())
49}
examples/clear-database.rs (line 18)
9fn main() -> Result<(), Box<dyn Error>> {
10    let env_path = Path::new("target").join("clear-database.mdb");
11
12    let _ = fs::remove_dir_all(&env_path);
13
14    fs::create_dir_all(&env_path)?;
15    let env = EnvOpenOptions::new()
16        .map_size(10 * 1024 * 1024) // 10MB
17        .max_dbs(3)
18        .open(env_path)?;
19
20    let db = env.create_database(Some("first"))?;
21    let mut wtxn = env.write_txn()?;
22
23    // We fill the db database with entries.
24    db.put(&mut wtxn, b"I am here", b"to test things")?;
25    db.put(&mut wtxn, b"I am here too", b"for the same purpose")?;
26
27    wtxn.commit()?;
28
29    let mut wtxn = env.write_txn()?;
30    db.clear(&mut wtxn)?;
31    db.put(&mut wtxn, b"And I come back", b"to test things")?;
32
33    let mut iter = db.iter(&wtxn)?;
34    assert_eq!(
35        iter.next().transpose()?,
36        Some((&b"And I come back"[..], &b"to test things"[..]))
37    );
38    assert_eq!(iter.next().transpose()?, None);
39
40    drop(iter);
41    wtxn.commit()?;
42
43    let rtxn = env.read_txn()?;
44    let mut iter = db.iter(&rtxn)?;
45    assert_eq!(
46        iter.next().transpose()?,
47        Some((&b"And I come back"[..], &b"to test things"[..]))
48    );
49    assert_eq!(iter.next().transpose()?, None);
50
51    Ok(())
52}
examples/nested.rs (line 15)
7fn main() -> Result<(), Box<dyn Error>> {
8    let path = Path::new("target").join("heed.mdb");
9
10    fs::create_dir_all(&path)?;
11
12    let env = EnvOpenOptions::new()
13        .map_size(10 * 1024 * 1024) // 10MB
14        .max_dbs(3000)
15        .open(path)?;
16
17    // here the key will be an str and the data will be a slice of u8
18    let db = env.create_database(None)?;
19
20    // clear db
21    let mut wtxn = env.write_txn()?;
22    db.clear(&mut wtxn)?;
23    wtxn.commit()?;
24
25    // -----
26
27    let mut wtxn = env.write_txn()?;
28    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
29
30    db.put(&mut nwtxn, b"what", &[4, 5][..])?;
31    let ret = db.get(&nwtxn, b"what")?;
32    println!("nested(1) \"what\": {:?}", ret);
33
34    println!("nested(1) abort");
35    nwtxn.abort()?;
36
37    let ret = db.get(&wtxn, b"what")?;
38    println!("parent \"what\": {:?}", ret);
39
40    // ------
41    println!();
42
43    // also try with multiple levels of nesting
44    let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
45    let mut nnwtxn = env.nested_write_txn(&mut nwtxn)?;
46
47    db.put(&mut nnwtxn, b"humm...", &[6, 7][..])?;
48    let ret = db.get(&nnwtxn, b"humm...")?;
49    println!("nested(2) \"humm...\": {:?}", ret);
50
51    println!("nested(2) commit");
52    nnwtxn.commit()?;
53    nwtxn.commit()?;
54
55    let ret = db.get(&wtxn, b"humm...")?;
56    println!("parent \"humm...\": {:?}", ret);
57
58    db.put(&mut wtxn, b"hello", &[2, 3][..])?;
59
60    let ret = db.get(&wtxn, b"hello")?;
61    println!("parent \"hello\": {:?}", ret);
62
63    println!("parent commit");
64    wtxn.commit()?;
65
66    // ------
67    println!();
68
69    let rtxn = env.read_txn()?;
70
71    let ret = db.get(&rtxn, b"hello")?;
72    println!("parent (reader) \"hello\": {:?}", ret);
73
74    let ret = db.get(&rtxn, b"humm...")?;
75    println!("parent (reader) \"humm...\": {:?}", ret);
76
77    Ok(())
78}

Trait Implementations§

Source§

impl Clone for EnvOpenOptions

Source§

fn clone(&self) -> EnvOpenOptions

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for EnvOpenOptions

Source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.