NextGraph
/
rkv
mirror of https://github.com/nextgraph-org/rkv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

update lmdb-rkv to latest version 0.11 (#105)

Browse Source 
Updates Iter impls to have `type Item = Result<(&'env [u8], Option<Value<'env>>), StoreError>`
without.crypto
Myk Melez 5 years ago committed by GitHub
parent a81dfbeb10
commit 9ff784c8dd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 90 additions and 82 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      Cargo.toml
  2. 6
      examples/iterator.rs
  3. 6
      examples/simple-store.rs
  4. 128
      src/env.rs
  5. 9
      src/store/multi.rs
  6. 9
      src/store/single.rs
  7. 10
      tests/multi-integer-store.rs

4
Cargo.toml
Unescape View File

@ -1,6 +1,6 @@
[package]
name = "rkv"
version = "0.7.0"
version = "0.8.0"
authors = ["Richard Newman <rnewman@twinql.com>", "Nan Jiang <najiang@mozilla.com>", "Myk Melez <myk@mykzilla.org>"]
description = "a simple, humane, typed Rust interface to LMDB"
license = "Apache-2.0"
@ -18,8 +18,8 @@ backtrace = ["failure/backtrace", "failure/std"]
[dependencies]
arrayref = "0.3"
bincode = "1.0"
lmdb-rkv = "0.11"
lazy_static = "1.0.2"
lmdb-rkv = "0.11"
ordered-float = "1.0"
uuid = "0.7"
serde = "1.0"

6
examples/iterator.rs
Unescape View File

@ -38,7 +38,7 @@ fn main() {
// Reader::iter_start() iterates from the first item in the store, and
// returns the (key, value) tuples in order.
let mut iter = store.iter_start(&reader).unwrap();
while let Some((country, city)) = iter.next() {
while let Some(Ok((country, city))) = iter.next() {
println!("{}, {:?}", str::from_utf8(country).unwrap(), city);
}
@ -47,14 +47,14 @@ fn main() {
// Reader::iter_from() iterates from the first key equal to or greater
// than the given key.
let mut iter = store.iter_from(&reader, "Japan").unwrap();
while let Some((country, city)) = iter.next() {
while let Some(Ok((country, city))) = iter.next() {
println!("{}, {:?}", str::from_utf8(country).unwrap(), city);
}
println!("");
println!("Iterating from the given prefix...");
let mut iter = store.iter_from(&reader, "Un").unwrap();
while let Some((country, city)) = iter.next() {
while let Some(Ok((country, city))) = iter.next() {
println!("{}, {:?}", str::from_utf8(country).unwrap(), city);
}
}

6
examples/simple-store.rs
Unescape View File

@ -25,9 +25,9 @@ fn getput<'env, 's>(mut store: MultiStore, writer: &'env mut RwTransaction, ids:
// we convert the writer into a cursor so that we can safely read
for k in keys.iter() {
// this is a multi-valued database, so get returns an iterator
let iter = store.get(writer, k).unwrap();
for (_key, val) in iter {
if let Value::Str(s) = val.unwrap().unwrap() {
let mut iter = store.get(writer, k).unwrap();
while let Some(Ok((_key, val))) = iter.next() {
if let Value::Str(s) = val.unwrap() {
ids.push(s.to_owned());
} else {
panic!("didn't get a string back!");

128
src/env.rs
Unescape View File

@ -437,10 +437,10 @@ mod tests {
let mut writer = k.write().unwrap();
{
let mut iter = multistore.get(&mut writer, "str1").unwrap();
let (id, val) = iter.next().unwrap();
assert_eq!((id, val.unwrap().unwrap()), (&b"str1"[..], Value::Str("str1 bar")));
let (id, val) = iter.next().unwrap();
assert_eq!((id, val.unwrap().unwrap()), (&b"str1"[..], Value::Str("str1 foo")));
let (id, val) = iter.next().unwrap().unwrap();
assert_eq!((id, val), (&b"str1"[..], Some(Value::Str("str1 bar"))));
let (id, val) = iter.next().unwrap().unwrap();
assert_eq!((id, val), (&b"str1"[..], Some(Value::Str("str1 foo"))));
}
writer.commit().unwrap();
let mut writer = k.write().unwrap();
@ -672,24 +672,24 @@ mod tests {
// Reader.iter() returns (key, value) tuples ordered by key.
let mut iter = sk.iter_start(&reader).unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "bar");
assert_eq!(val.expect("value"), Some(Value::Bool(true)));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Bool(true)));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "baz");
assert_eq!(val.expect("value"), Some(Value::Str("héllo, yöu")));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Str("héllo, yöu")));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "foo");
assert_eq!(val.expect("value"), Some(Value::I64(1234)));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::I64(1234)));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
assert_eq!(val.expect("value"), Some(Value::Str("Emil.RuleZ!")));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
// Iterators don't loop. Once one returns None, additional calls
@ -699,23 +699,23 @@ mod tests {
// Reader.iter_from() begins iteration at the first key equal to
// or greater than the given key.
let mut iter = sk.iter_from(&reader, "moo").unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
// Reader.iter_from() works as expected when the given key is a prefix
// of a key in the store.
let mut iter = sk.iter_from(&reader, "no").unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
}
@ -807,86 +807,86 @@ mod tests {
// Iterate through the whole store in "s1"
let mut iter = s1.iter_start(&reader).unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "bar");
assert_eq!(val.expect("value"), Some(Value::Bool(true)));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Bool(true)));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "baz");
assert_eq!(val.expect("value"), Some(Value::Str("héllo, yöu")));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Str("héllo, yöu")));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "foo");
assert_eq!(val.expect("value"), Some(Value::I64(1234)));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::I64(1234)));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
assert_eq!(val.expect("value"), Some(Value::Str("Emil.RuleZ!")));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
// Iterate through the whole store in "s2"
let mut iter = s2.iter_start(&reader).unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "bar");
assert_eq!(val.expect("value"), Some(Value::Bool(true)));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Bool(true)));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "baz");
assert_eq!(val.expect("value"), Some(Value::Str("héllo, yöu")));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Str("héllo, yöu")));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "foo");
assert_eq!(val.expect("value"), Some(Value::I64(1234)));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::I64(1234)));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
assert_eq!(val.expect("value"), Some(Value::Str("Emil.RuleZ!")));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
// Iterate from a given key in "s1"
let mut iter = s1.iter_from(&reader, "moo").unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
// Iterate from a given key in "s2"
let mut iter = s2.iter_from(&reader, "moo").unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
// Iterate from a given prefix in "s1"
let mut iter = s1.iter_from(&reader, "no").unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
// Iterate from a given prefix in "s2"
let mut iter = s2.iter_from(&reader, "no").unwrap();
let (key, val) = iter.next().unwrap();
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "noo");
assert_eq!(val.expect("value"), Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap();
assert_eq!(val, Some(Value::F64(1234.0.into())));
let (key, val) = iter.next().unwrap().unwrap();
assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
assert_eq!(val.expect("value"), Some(Value::Str("米克規則")));
assert_eq!(val, Some(Value::Str("米克規則")));
assert!(iter.next().is_none());
}

9
src/store/multi.rs
Unescape View File

@ -149,13 +149,16 @@ impl<'env> Iterator for MultiIter<'env> {
*/
impl<'env> Iterator for Iter<'env> {
type Item = (&'env [u8], Result<Option<Value<'env>>, StoreError>);
type Item = Result<(&'env [u8], Option<Value<'env>>), StoreError>;
fn next(&mut self) -> Option<Self::Item> {
match self.iter.next() {
None => None,
Some(Ok((key, bytes))) => Some((key, read_transform(Ok(bytes)))),
Some(Err(_)) => None,
Some(Ok((key, bytes))) => match read_transform(Ok(bytes)) {
Ok(val) => Some(Ok((key, val))),
Err(err) => Some(Err(err)),
},
Some(Err(err)) => Some(Err(StoreError::LmdbError(err))),
}
}
}

9
src/store/single.rs
Unescape View File

@ -104,13 +104,16 @@ impl SingleStore {
}
impl<'env> Iterator for Iter<'env> {
type Item = (&'env [u8], Result<Option<Value<'env>>, StoreError>);
type Item = Result<(&'env [u8], Option<Value<'env>>), StoreError>;
fn next(&mut self) -> Option<Self::Item> {
match self.iter.next() {
None => None,
Some(Ok((key, bytes))) => Some((key, read_transform(Ok(bytes)))),
Some(Err(_)) => None,
Some(Ok((key, bytes))) => match read_transform(Ok(bytes)) {
Ok(val) => Some(Ok((key, val))),
Err(err) => Some(Err(err)),
},
Some(Err(err)) => Some(Err(StoreError::LmdbError(err))),
}
}
}

10
tests/multi-integer-store.rs
Unescape View File

@ -36,18 +36,20 @@ fn test_multi_integer_keys() {
let vals = $store
.get(&writer, $key)
.expect("read")
.map(|result| result.expect("ok"))
.map(|(_, v)| v.expect("multi read"))
.collect::<Option<Vec<Value>>>();
assert_eq!(vals, Some(vec![Value::Str("hello1"), Value::Str("hello2"), Value::Str("hello3")]));
.collect::<Vec<Value>>();
assert_eq!(vals, vec![Value::Str("hello1"), Value::Str("hello2"), Value::Str("hello3")]);
writer.commit().expect("committed");
let reader = k.read().expect("reader");
let vals = $store
.get(&reader, $key)
.expect("read")
.map(|result| result.expect("ok"))
.map(|(_, v)| v.expect("multi read"))
.collect::<Option<Vec<Value>>>();
assert_eq!(vals, Some(vec![Value::Str("hello1"), Value::Str("hello2"), Value::Str("hello3")]));
.collect::<Vec<Value>>();
assert_eq!(vals, vec![Value::Str("hello1"), Value::Str("hello2"), Value::Str("hello3")]);
}};
}

Write Preview
Loading…
Cancel
Save