leveldb 0.8.6

An interface for leveldb
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use utils::{open_database,tmpdir,db_put_simple};
use leveldb::iterator::Iterable;
use leveldb::iterator::LevelDBIterator;
use leveldb::options::{ReadOptions};

#[test]
fn test_iterator() {
  let tmp = tmpdir("iter");
  let database = &mut open_database(tmp.path(), true);
  db_put_simple(database, 1, &[1]);
  db_put_simple(database, 2, &[2]);

  let read_opts = ReadOptions::new();
  let mut iter = database.iter(read_opts);

  let entry = iter.next();
  assert!(entry.is_some());
  assert_eq!(entry.unwrap(), (1, vec![1]));
  let entry2 = iter.next();
  assert!(entry2.is_some());
  assert_eq!(entry2.unwrap(), (2, vec![2]));
  assert!(iter.next().is_none());
}

#[test]
fn test_iterator_reverse() {
    let tmp = tmpdir("iter");
    let database = &mut open_database(tmp.path(), true);
    db_put_simple(database, 1, &[1]);
    db_put_simple(database, 2, &[2]);

    let read_opts = ReadOptions::new();
    let mut iter = database.iter(read_opts).reverse();

    let entry = iter.next();
    assert!(entry.is_some());
    assert_eq!(entry.unwrap(), (2, vec![2]));
    let entry2 = iter.next();
    assert!(entry2.is_some());
    assert_eq!(entry2.unwrap(), (1, vec![1]));
    assert!(iter.next().is_none());
}

#[test]
fn test_iterator_last() {
  let tmp = tmpdir("iter_last");
  let database = &mut open_database(tmp.path(), true);
  db_put_simple(database, 1, &[1]);
  db_put_simple(database, 2, &[2]);

  let read_opts = ReadOptions::new();
  let iter = database.iter(read_opts);

  assert!(iter.last().is_some());
}

#[test]
fn test_iterator_from_to() {
  let tmp = tmpdir("from_to");
  let database = &mut open_database(tmp.path(), true);
  db_put_simple(database, 1, &[1]);
  db_put_simple(database, 2, &[2]);
  db_put_simple(database, 3, &[3]);
  db_put_simple(database, 4, &[4]);
  db_put_simple(database, 5, &[5]);

  let from = 2;
  let to = 4;
  let read_opts = ReadOptions::new();
  let mut iter = database.iter(read_opts).from(&from).to(&to);

  assert_eq!(iter.next().unwrap(), (2,vec![2]));
  assert_eq!(iter.last().unwrap(), (4,vec![4]));
}


#[test]
fn test_key_iterator() {
  let tmp = tmpdir("key_iter");
  let database = &mut open_database(tmp.path(), true);
  db_put_simple(database, 1, &[1]);
  db_put_simple(database, 2, &[2]);

  let iterable: &mut Iterable<i32> = database;

  let read_opts = ReadOptions::new();
  let mut iter = iterable.keys_iter(read_opts);
  let value = iter.next().unwrap();
  assert_eq!(value, 1);
}

#[test]
fn test_value_iterator() {
  let tmp = tmpdir("value_iter");
  let database = &mut open_database(tmp.path(), true);
  db_put_simple(database, 1, &[1]);
  db_put_simple(database, 2, &[2]);

  let iterable: &mut Iterable<i32> = database;

  let read_opts = ReadOptions::new();
  let mut iter = iterable.value_iter(read_opts);
  let value = iter.next().unwrap();
  assert_eq!(value, vec![1]);
}