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

update for rustc 1.0.0-nightly (e2fa53e59 2015-03-20) (built 2015-03-20)

Browse Source
without.crypto
Dan Burkert 10 years ago
parent 28660edc12
commit 8e52bdbb79
5 changed files with 87 additions and 87 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. 1
      Cargo.toml
  2. 107
      src/cursor.rs
  3. 16
      src/environment.rs
  4. 11
      src/lib.rs
  5. 39
      src/transaction.rs

1
Cargo.toml
Unescape View File

@ -24,3 +24,4 @@ bitflags = "*"
[dev-dependencies] [dev-dependencies]
rand = "*" rand = "*"
tempdir = "*"

107
src/cursor.rs
Unescape View File

@ -290,12 +290,13 @@ impl <'txn> Iterator for IterDup<'txn> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use std::{fs, ptr}; use std::ptr;
use test::{Bencher, black_box}; use test::{Bencher, black_box};
use ffi::*; use tempdir::TempDir;
use environment::*; use environment::*;
use ffi::*;
use flags::*; use flags::*;
use super::*; use super::*;
use test_utils::*; use test_utils::*;
@ -303,7 +304,7 @@ mod test {
#[test] #[test]
fn test_get() { fn test_get() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
@ -313,27 +314,27 @@ mod test {
txn.put(db, b"key3", b"val3", WriteFlags::empty()).unwrap(); txn.put(db, b"key3", b"val3", WriteFlags::empty()).unwrap();
let cursor = txn.open_ro_cursor(db).unwrap(); let cursor = txn.open_ro_cursor(db).unwrap();
assert_eq!((Some(b"key1"), b"val1"), assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
cursor.get(None, None, MDB_FIRST).unwrap()); cursor.get(None, None, MDB_FIRST).unwrap());
assert_eq!((Some(b"key1"), b"val1"), assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
cursor.get(None, None, MDB_GET_CURRENT).unwrap()); cursor.get(None, None, MDB_GET_CURRENT).unwrap());
assert_eq!((Some(b"key2"), b"val2"), assert_eq!((Some(&b"key2"[..]), &b"val2"[..]),
cursor.get(None, None, MDB_NEXT).unwrap()); cursor.get(None, None, MDB_NEXT).unwrap());
assert_eq!((Some(b"key1"), b"val1"), assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
cursor.get(None, None, MDB_PREV).unwrap()); cursor.get(None, None, MDB_PREV).unwrap());
assert_eq!((Some(b"key3"), b"val3"), assert_eq!((Some(&b"key3"[..]), &b"val3"[..]),
cursor.get(None, None, MDB_LAST).unwrap()); cursor.get(None, None, MDB_LAST).unwrap());
assert_eq!((None, b"val2"), assert_eq!((None, &b"val2"[..]),
cursor.get(Some(b"key2"), None, MDB_SET).unwrap()); cursor.get(Some(b"key2"), None, MDB_SET).unwrap());
assert_eq!((Some(b"key3"), b"val3"), assert_eq!((Some(&b"key3"[..]), &b"val3"[..]),
cursor.get(Some(b"key3"), None, MDB_SET_KEY).unwrap()); cursor.get(Some(&b"key3"[..]), None, MDB_SET_KEY).unwrap());
assert_eq!((Some(b"key3"), b"val3"), assert_eq!((Some(&b"key3"[..]), &b"val3"[..]),
cursor.get(Some(b"key2\0"), None, MDB_SET_RANGE).unwrap()); cursor.get(Some(&b"key2\0"[..]), None, MDB_SET_RANGE).unwrap());
} }
#[test] #[test]
fn test_get_dup() { fn test_get_dup() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.create_db(None, DUP_SORT).unwrap(); let db = env.create_db(None, DUP_SORT).unwrap();
@ -346,40 +347,40 @@ mod test {
txn.put(db, b"key2", b"val3", WriteFlags::empty()).unwrap(); txn.put(db, b"key2", b"val3", WriteFlags::empty()).unwrap();
let cursor = txn.open_ro_cursor(db).unwrap(); let cursor = txn.open_ro_cursor(db).unwrap();
assert_eq!((Some(b"key1"), b"val1"), assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
cursor.get(None, None, MDB_FIRST).unwrap()); cursor.get(None, None, MDB_FIRST).unwrap());
assert_eq!((None, b"val1"), assert_eq!((None, &b"val1"[..]),
cursor.get(None, None, MDB_FIRST_DUP).unwrap()); cursor.get(None, None, MDB_FIRST_DUP).unwrap());
assert_eq!((Some(b"key1"), b"val1"), assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
cursor.get(None, None, MDB_GET_CURRENT).unwrap()); cursor.get(None, None, MDB_GET_CURRENT).unwrap());
assert_eq!((Some(b"key2"), b"val1"), assert_eq!((Some(&b"key2"[..]), &b"val1"[..]),
cursor.get(None, None, MDB_NEXT_NODUP).unwrap()); cursor.get(None, None, MDB_NEXT_NODUP).unwrap());
assert_eq!((Some(b"key2"), b"val2"), assert_eq!((Some(&b"key2"[..]), &b"val2"[..]),
cursor.get(None, None, MDB_NEXT_DUP).unwrap()); cursor.get(None, None, MDB_NEXT_DUP).unwrap());
assert_eq!((Some(b"key2"), b"val3"), assert_eq!((Some(&b"key2"[..]), &b"val3"[..]),
cursor.get(None, None, MDB_NEXT_DUP).unwrap()); cursor.get(None, None, MDB_NEXT_DUP).unwrap());
assert!(cursor.get(None, None, MDB_NEXT_DUP).is_err()); assert!(cursor.get(None, None, MDB_NEXT_DUP).is_err());
assert_eq!((Some(b"key2"), b"val2"), assert_eq!((Some(&b"key2"[..]), &b"val2"[..]),
cursor.get(None, None, MDB_PREV_DUP).unwrap()); cursor.get(None, None, MDB_PREV_DUP).unwrap());
assert_eq!((None, b"val3"), assert_eq!((None, &b"val3"[..]),
cursor.get(None, None, MDB_LAST_DUP).unwrap()); cursor.get(None, None, MDB_LAST_DUP).unwrap());
assert_eq!((Some(b"key1"), b"val3"), assert_eq!((Some(&b"key1"[..]), &b"val3"[..]),
cursor.get(None, None, MDB_PREV_NODUP).unwrap()); cursor.get(None, None, MDB_PREV_NODUP).unwrap());
assert_eq!((None, b"val1"), assert_eq!((None, &b"val1"[..]),
cursor.get(Some(b"key1"), None, MDB_SET).unwrap()); cursor.get(Some(&b"key1"[..]), None, MDB_SET).unwrap());
assert_eq!((Some(b"key2"), b"val1"), assert_eq!((Some(&b"key2"[..]), &b"val1"[..]),
cursor.get(Some(b"key2"), None, MDB_SET_KEY).unwrap()); cursor.get(Some(&b"key2"[..]), None, MDB_SET_KEY).unwrap());
assert_eq!((Some(b"key2"), b"val1"), assert_eq!((Some(&b"key2"[..]), &b"val1"[..]),
cursor.get(Some(b"key1\0"), None, MDB_SET_RANGE).unwrap()); cursor.get(Some(&b"key1\0"[..]), None, MDB_SET_RANGE).unwrap());
assert_eq!((None, b"val3"), assert_eq!((None, &b"val3"[..]),
cursor.get(Some(b"key1"), Some(b"val3"), MDB_GET_BOTH).unwrap()); cursor.get(Some(&b"key1"[..]), Some(&b"val3"[..]), MDB_GET_BOTH).unwrap());
assert_eq!((None, b"val1"), assert_eq!((None, &b"val1"[..]),
cursor.get(Some(b"key2"), Some(b"val"), MDB_GET_BOTH_RANGE).unwrap()); cursor.get(Some(&b"key2"[..]), Some(&b"val"[..]), MDB_GET_BOTH_RANGE).unwrap());
} }
#[test] #[test]
fn test_get_dupfixed() { fn test_get_dupfixed() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.create_db(None, DUP_SORT | DUP_FIXED).unwrap(); let db = env.create_db(None, DUP_SORT | DUP_FIXED).unwrap();
@ -392,22 +393,22 @@ mod test {
txn.put(db, b"key2", b"val6", WriteFlags::empty()).unwrap(); txn.put(db, b"key2", b"val6", WriteFlags::empty()).unwrap();
let cursor = txn.open_ro_cursor(db).unwrap(); let cursor = txn.open_ro_cursor(db).unwrap();
assert_eq!((Some(b"key1"), b"val1"), assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
cursor.get(None, None, MDB_FIRST).unwrap()); cursor.get(None, None, MDB_FIRST).unwrap());
assert_eq!((None, b"val1val2val3"), assert_eq!((None, &b"val1val2val3"[..]),
cursor.get(None, None, MDB_GET_MULTIPLE).unwrap()); cursor.get(None, None, MDB_GET_MULTIPLE).unwrap());
assert!(cursor.get(None, None, MDB_NEXT_MULTIPLE).is_err()); assert!(cursor.get(None, None, MDB_NEXT_MULTIPLE).is_err());
} }
#[test] #[test]
fn test_iter() { fn test_iter() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
let items = vec!((b"key1", b"val1"), let items: Vec<(&[u8], &[u8])> = vec!((b"key1", b"val1"),
(b"key2", b"val2"), (b"key2", b"val2"),
(b"key3", b"val3")); (b"key3", b"val3"));
{ {
let mut txn = env.begin_rw_txn().unwrap(); let mut txn = env.begin_rw_txn().unwrap();
@ -433,19 +434,19 @@ mod test {
#[test] #[test]
fn test_iter_dup() { fn test_iter_dup() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.create_db(None, DUP_SORT).unwrap(); let db = env.create_db(None, DUP_SORT).unwrap();
let items = vec!((b"a", b"1"), let items: Vec<(&[u8], &[u8])> = vec!((b"a", b"1"),
(b"a", b"2"), (b"a", b"2"),
(b"a", b"3"), (b"a", b"3"),
(b"b", b"1"), (b"b", b"1"),
(b"b", b"2"), (b"b", b"2"),
(b"b", b"3"), (b"b", b"3"),
(b"c", b"1"), (b"c", b"1"),
(b"c", b"2"), (b"c", b"2"),
(b"c", b"3")); (b"c", b"3"));
{ {
let mut txn = env.begin_rw_txn().unwrap(); let mut txn = env.begin_rw_txn().unwrap();
@ -480,7 +481,7 @@ mod test {
#[test] #[test]
fn test_put_del() { fn test_put_del() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
@ -491,11 +492,11 @@ mod test {
cursor.put(b"key2", b"val2", WriteFlags::empty()).unwrap(); cursor.put(b"key2", b"val2", WriteFlags::empty()).unwrap();
cursor.put(b"key3", b"val3", WriteFlags::empty()).unwrap(); cursor.put(b"key3", b"val3", WriteFlags::empty()).unwrap();
assert_eq!((Some(b"key3"), b"val3"), assert_eq!((Some(&b"key3"[..]), &b"val3"[..]),
cursor.get(None, None, MDB_GET_CURRENT).unwrap()); cursor.get(None, None, MDB_GET_CURRENT).unwrap());
cursor.del(WriteFlags::empty()).unwrap(); cursor.del(WriteFlags::empty()).unwrap();
assert_eq!((Some(b"key2"), b"val2"), assert_eq!((Some(&b"key2"[..]), &b"val2"[..]),
cursor.get(None, None, MDB_LAST).unwrap()); cursor.get(None, None, MDB_LAST).unwrap());
} }

16
src/environment.rs
Unescape View File

@ -1,6 +1,6 @@
use libc::{c_uint, size_t, mode_t}; use libc::{c_uint, size_t, mode_t};
use std::ffi::{AsOsStr, CString}; use std::ffi::{AsOsStr, CString};
use std::os::unix::OsStrExt; use std::os::unix::ffi::OsStrExt;
use std::path::Path; use std::path::Path;
use std::ptr; use std::ptr;
use std::sync::Mutex; use std::sync::Mutex;
@ -252,7 +252,7 @@ impl EnvironmentBuilder {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use std::fs; use tempdir::TempDir;
use flags::*; use flags::*;
@ -260,7 +260,7 @@ mod test {
#[test] #[test]
fn test_open() { fn test_open() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
// opening non-existent env with read-only should fail // opening non-existent env with read-only should fail
assert!(Environment::new().set_flags(READ_ONLY) assert!(Environment::new().set_flags(READ_ONLY)
@ -278,7 +278,7 @@ mod test {
#[test] #[test]
fn test_begin_txn() { fn test_begin_txn() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
{ // writable environment { // writable environment
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
@ -299,7 +299,7 @@ mod test {
#[test] #[test]
fn test_open_db() { fn test_open_db() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().set_max_dbs(1) let env = Environment::new().set_max_dbs(1)
.open(dir.path()) .open(dir.path())
.unwrap(); .unwrap();
@ -310,7 +310,7 @@ mod test {
#[test] #[test]
fn test_create_db() { fn test_create_db() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().set_max_dbs(11) let env = Environment::new().set_max_dbs(11)
.open(dir.path()) .open(dir.path())
.unwrap(); .unwrap();
@ -321,7 +321,7 @@ mod test {
#[test] #[test]
fn test_close_database() { fn test_close_database() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let mut env = Environment::new().set_max_dbs(10) let mut env = Environment::new().set_max_dbs(10)
.open(dir.path()) .open(dir.path())
.unwrap(); .unwrap();
@ -333,7 +333,7 @@ mod test {
#[test] #[test]
fn test_sync() { fn test_sync() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
{ {
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
assert!(env.sync(true).is_ok()); assert!(env.sync(true).is_ok());

11
src/lib.rs
Unescape View File

@ -2,12 +2,13 @@
//! [Symas Lightning Memory-Mapped Database (LMDB)](http://symas.com/mdb/). //! [Symas Lightning Memory-Mapped Database (LMDB)](http://symas.com/mdb/).
#![feature(core, libc, optin_builtin_traits, std_misc, unsafe_destructor)] #![feature(core, libc, optin_builtin_traits, std_misc, unsafe_destructor)]
#![cfg_attr(test, feature(tempdir, test))] #![cfg_attr(test, feature(test))]
extern crate libc; extern crate libc;
extern crate "lmdb-sys" as ffi; extern crate "lmdb-sys" as ffi;
#[cfg(test)] extern crate rand; #[cfg(test)] extern crate rand;
#[cfg(test)] extern crate tempdir;
#[cfg(test)] extern crate test; #[cfg(test)] extern crate test;
#[macro_use] extern crate bitflags; #[macro_use] extern crate bitflags;
@ -60,7 +61,7 @@ mod transaction;
#[cfg(test)] #[cfg(test)]
mod test_utils { mod test_utils {
use std::fs; use tempdir::TempDir;
use super::*; use super::*;
@ -72,14 +73,14 @@ mod test_utils {
format!("data{}", n) format!("data{}", n)
} }
pub fn setup_bench_db<'a>(num_rows: u32) -> (fs::TempDir, Environment) { pub fn setup_bench_db<'a>(num_rows: u32) -> (TempDir, Environment) {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
{ {
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
let mut txn = env.begin_rw_txn().unwrap(); let mut txn = env.begin_rw_txn().unwrap();
for i in range(0, num_rows) { for i in 0..num_rows {
txn.put(db, txn.put(db,
get_key(i).as_bytes(), get_key(i).as_bytes(),
get_data(i).as_bytes(), get_data(i).as_bytes(),

39
src/transaction.rs
Unescape View File

@ -359,23 +359,24 @@ impl <'env> Transaction<'env> for RwTransaction<'env> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use std::ptr;
use rand::{Rng, XorShiftRng}; use rand::{Rng, XorShiftRng};
use std::io::Write; use std::io::Write;
use std::sync::{Arc, Barrier, Future}; use std::sync::{Arc, Barrier, Future};
use std::{fs, ptr};
use test::{Bencher, black_box}; use test::{Bencher, black_box};
use ffi::*; use tempdir::TempDir;
use environment::*; use environment::*;
use error::*; use error::*;
use ffi::*;
use flags::*; use flags::*;
use super::*; use super::*;
use test_utils::*; use test_utils::*;
#[test] #[test]
fn test_put_get_del() { fn test_put_get_del() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
@ -397,7 +398,7 @@ mod test {
#[test] #[test]
fn test_reserve() { fn test_reserve() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
@ -418,7 +419,7 @@ mod test {
#[test] #[test]
fn test_inactive_txn() { fn test_inactive_txn() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
@ -436,7 +437,7 @@ mod test {
#[test] #[test]
fn test_nested_txn() { fn test_nested_txn() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
@ -456,7 +457,7 @@ mod test {
#[test] #[test]
fn test_clear_db() { fn test_clear_db() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap(); let env = Environment::new().open(dir.path()).unwrap();
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
@ -479,7 +480,7 @@ mod test {
#[test] #[test]
fn test_drop_db() { fn test_drop_db() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Environment::new().set_max_dbs(2) let env = Environment::new().set_max_dbs(2)
.open(dir.path()).unwrap(); .open(dir.path()).unwrap();
let db = env.create_db(Some("test"), DatabaseFlags::empty()).unwrap(); let db = env.create_db(Some("test"), DatabaseFlags::empty()).unwrap();
@ -500,7 +501,7 @@ mod test {
#[test] #[test]
fn test_concurrent_readers_single_writer() { fn test_concurrent_readers_single_writer() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env: Arc<Environment> = Arc::new(Environment::new().open(dir.path()).unwrap()); let env: Arc<Environment> = Arc::new(Environment::new().open(dir.path()).unwrap());
let n = 10usize; // Number of concurrent readers let n = 10usize; // Number of concurrent readers
@ -510,7 +511,7 @@ mod test {
let key = b"key"; let key = b"key";
let val = b"val"; let val = b"val";
for _ in range(0, n) { for _ in 0..n {
let reader_env = env.clone(); let reader_env = env.clone();
let reader_barrier = barrier.clone(); let reader_barrier = barrier.clone();
@ -542,7 +543,7 @@ mod test {
#[test] #[test]
fn test_concurrent_writers() { fn test_concurrent_writers() {
let dir = fs::TempDir::new("test").unwrap(); let dir = TempDir::new("test").unwrap();
let env = Arc::new(Environment::new().open(dir.path()).unwrap()); let env = Arc::new(Environment::new().open(dir.path()).unwrap());
let n = 10usize; // Number of concurrent writers let n = 10usize; // Number of concurrent writers
@ -551,7 +552,7 @@ mod test {
let key = "key"; let key = "key";
let val = "val"; let val = "val";
for i in range(0, n) { for i in 0..n {
let writer_env = env.clone(); let writer_env = env.clone();
futures.push(Future::spawn(move|| { futures.push(Future::spawn(move|| {
@ -570,7 +571,7 @@ mod test {
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
let txn = env.begin_ro_txn().unwrap(); let txn = env.begin_ro_txn().unwrap();
for i in range(0, n) { for i in 0..n {
assert_eq!( assert_eq!(
format!("{}{}", val, i).as_bytes(), format!("{}{}", val, i).as_bytes(),
txn.get(db, format!("{}{}", key, i).as_bytes()).unwrap()); txn.get(db, format!("{}{}", key, i).as_bytes()).unwrap());
@ -584,8 +585,7 @@ mod test {
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
let txn = env.begin_ro_txn().unwrap(); let txn = env.begin_ro_txn().unwrap();
let mut keys: Vec<String> = range(0, n).map(|n| get_key(n)) let mut keys: Vec<String> = (0..n).map(|n| get_key(n)).collect();
.collect::<Vec<_>>();
XorShiftRng::new_unseeded().shuffle(keys.as_mut_slice()); XorShiftRng::new_unseeded().shuffle(keys.as_mut_slice());
b.iter(|| { b.iter(|| {
@ -604,8 +604,7 @@ mod test {
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
let _txn = env.begin_ro_txn().unwrap(); let _txn = env.begin_ro_txn().unwrap();
let mut keys: Vec<String> = range(0, n).map(|n| get_key(n)) let mut keys: Vec<String> = (0..n).map(|n| get_key(n)).collect();
.collect::<Vec<_>>();
XorShiftRng::new_unseeded().shuffle(keys.as_mut_slice()); XorShiftRng::new_unseeded().shuffle(keys.as_mut_slice());
let dbi = db.dbi(); let dbi = db.dbi();
@ -634,8 +633,7 @@ mod test {
let (_dir, env) = setup_bench_db(0); let (_dir, env) = setup_bench_db(0);
let db = env.open_db(None).unwrap(); let db = env.open_db(None).unwrap();
let mut items: Vec<(String, String)> = range(0, n).map(|n| (get_key(n), get_data(n))) let mut items: Vec<(String, String)> = (0..n).map(|n| (get_key(n), get_data(n))).collect();
.collect::<Vec<_>>();
XorShiftRng::new_unseeded().shuffle(items.as_mut_slice()); XorShiftRng::new_unseeded().shuffle(items.as_mut_slice());
b.iter(|| { b.iter(|| {
@ -653,8 +651,7 @@ mod test {
let (_dir, _env) = setup_bench_db(0); let (_dir, _env) = setup_bench_db(0);
let db = _env.open_db(None).unwrap(); let db = _env.open_db(None).unwrap();
let mut items: Vec<(String, String)> = range(0, n).map(|n| (get_key(n), get_data(n))) let mut items: Vec<(String, String)> = (0..n).map(|n| (get_key(n), get_data(n))).collect();
.collect::<Vec<_>>();
XorShiftRng::new_unseeded().shuffle(items.as_mut_slice()); XorShiftRng::new_unseeded().shuffle(items.as_mut_slice());
let dbi = db.dbi(); let dbi = db.dbi();

Write Preview
Loading…
Cancel
Save