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. 87
      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]
rand = "*"
tempdir = "*"

87
src/cursor.rs
Unescape View File

@ -290,12 +290,13 @@ impl <'txn> Iterator for IterDup<'txn> {
#[cfg(test)]
mod test {
use std::{fs, ptr};
use std::ptr;
use test::{Bencher, black_box};
use ffi::*;
use tempdir::TempDir;
use environment::*;
use ffi::*;
use flags::*;
use super::*;
use test_utils::*;
@ -303,7 +304,7 @@ mod test {
#[test]
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 db = env.open_db(None).unwrap();
@ -313,27 +314,27 @@ mod test {
txn.put(db, b"key3", b"val3", WriteFlags::empty()).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());
assert_eq!((Some(b"key1"), b"val1"),
assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
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());
assert_eq!((Some(b"key1"), b"val1"),
assert_eq!((Some(&b"key1"[..]), &b"val1"[..]),
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());
assert_eq!((None, b"val2"),
assert_eq!((None, &b"val2"[..]),
cursor.get(Some(b"key2"), None, MDB_SET).unwrap());
assert_eq!((Some(b"key3"), b"val3"),
cursor.get(Some(b"key3"), None, MDB_SET_KEY).unwrap());
assert_eq!((Some(b"key3"), b"val3"),
cursor.get(Some(b"key2\0"), None, MDB_SET_RANGE).unwrap());
assert_eq!((Some(&b"key3"[..]), &b"val3"[..]),
cursor.get(Some(&b"key3"[..]), None, MDB_SET_KEY).unwrap());
assert_eq!((Some(&b"key3"[..]), &b"val3"[..]),
cursor.get(Some(&b"key2\0"[..]), None, MDB_SET_RANGE).unwrap());
}
#[test]
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 db = env.create_db(None, DUP_SORT).unwrap();
@ -346,40 +347,40 @@ mod test {
txn.put(db, b"key2", b"val3", WriteFlags::empty()).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());
assert_eq!((None, b"val1"),
assert_eq!((None, &b"val1"[..]),
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());
assert_eq!((Some(b"key2"), b"val1"),
assert_eq!((Some(&b"key2"[..]), &b"val1"[..]),
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());
assert_eq!((Some(b"key2"), b"val3"),
assert_eq!((Some(&b"key2"[..]), &b"val3"[..]),
cursor.get(None, None, MDB_NEXT_DUP).unwrap());
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());
assert_eq!((None, b"val3"),
assert_eq!((None, &b"val3"[..]),
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());
assert_eq!((None, b"val1"),
cursor.get(Some(b"key1"), None, MDB_SET).unwrap());
assert_eq!((Some(b"key2"), b"val1"),
cursor.get(Some(b"key2"), None, MDB_SET_KEY).unwrap());
assert_eq!((Some(b"key2"), b"val1"),
cursor.get(Some(b"key1\0"), None, MDB_SET_RANGE).unwrap());
assert_eq!((None, b"val3"),
cursor.get(Some(b"key1"), Some(b"val3"), MDB_GET_BOTH).unwrap());
assert_eq!((None, b"val1"),
cursor.get(Some(b"key2"), Some(b"val"), MDB_GET_BOTH_RANGE).unwrap());
assert_eq!((None, &b"val1"[..]),
cursor.get(Some(&b"key1"[..]), None, MDB_SET).unwrap());
assert_eq!((Some(&b"key2"[..]), &b"val1"[..]),
cursor.get(Some(&b"key2"[..]), None, MDB_SET_KEY).unwrap());
assert_eq!((Some(&b"key2"[..]), &b"val1"[..]),
cursor.get(Some(&b"key1\0"[..]), None, MDB_SET_RANGE).unwrap());
assert_eq!((None, &b"val3"[..]),
cursor.get(Some(&b"key1"[..]), Some(&b"val3"[..]), MDB_GET_BOTH).unwrap());
assert_eq!((None, &b"val1"[..]),
cursor.get(Some(&b"key2"[..]), Some(&b"val"[..]), MDB_GET_BOTH_RANGE).unwrap());
}
#[test]
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 db = env.create_db(None, DUP_SORT | DUP_FIXED).unwrap();
@ -392,20 +393,20 @@ mod test {
txn.put(db, b"key2", b"val6", WriteFlags::empty()).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());
assert_eq!((None, b"val1val2val3"),
assert_eq!((None, &b"val1val2val3"[..]),
cursor.get(None, None, MDB_GET_MULTIPLE).unwrap());
assert!(cursor.get(None, None, MDB_NEXT_MULTIPLE).is_err());
}
#[test]
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 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"key3", b"val3"));
@ -433,11 +434,11 @@ mod test {
#[test]
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 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"3"),
(b"b", b"1"),
@ -480,7 +481,7 @@ mod test {
#[test]
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 db = env.open_db(None).unwrap();
@ -491,11 +492,11 @@ mod test {
cursor.put(b"key2", b"val2", 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.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());
}

16
src/environment.rs
Unescape View File

@ -1,6 +1,6 @@
use libc::{c_uint, size_t, mode_t};
use std::ffi::{AsOsStr, CString};
use std::os::unix::OsStrExt;
use std::os::unix::ffi::OsStrExt;
use std::path::Path;
use std::ptr;
use std::sync::Mutex;
@ -252,7 +252,7 @@ impl EnvironmentBuilder {
#[cfg(test)]
mod test {
use std::fs;
use tempdir::TempDir;
use flags::*;
@ -260,7 +260,7 @@ mod test {
#[test]
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
assert!(Environment::new().set_flags(READ_ONLY)
@ -278,7 +278,7 @@ mod test {
#[test]
fn test_begin_txn() {
let dir = fs::TempDir::new("test").unwrap();
let dir = TempDir::new("test").unwrap();
{ // writable environment
let env = Environment::new().open(dir.path()).unwrap();
@ -299,7 +299,7 @@ mod test {
#[test]
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)
.open(dir.path())
.unwrap();
@ -310,7 +310,7 @@ mod test {
#[test]
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)
.open(dir.path())
.unwrap();
@ -321,7 +321,7 @@ mod test {
#[test]
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)
.open(dir.path())
.unwrap();
@ -333,7 +333,7 @@ mod test {
#[test]
fn test_sync() {
let dir = fs::TempDir::new("test").unwrap();
let dir = TempDir::new("test").unwrap();
{
let env = Environment::new().open(dir.path()).unwrap();
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/).
#![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 "lmdb-sys" as ffi;
#[cfg(test)] extern crate rand;
#[cfg(test)] extern crate tempdir;
#[cfg(test)] extern crate test;
#[macro_use] extern crate bitflags;
@ -60,7 +61,7 @@ mod transaction;
#[cfg(test)]
mod test_utils {
use std::fs;
use tempdir::TempDir;
use super::*;
@ -72,14 +73,14 @@ mod test_utils {
format!("data{}", n)
}
pub fn setup_bench_db<'a>(num_rows: u32) -> (fs::TempDir, Environment) {
let dir = fs::TempDir::new("test").unwrap();
pub fn setup_bench_db<'a>(num_rows: u32) -> (TempDir, Environment) {
let dir = TempDir::new("test").unwrap();
let env = Environment::new().open(dir.path()).unwrap();
{
let db = env.open_db(None).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,
get_key(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)]
mod test {
use std::ptr;
use rand::{Rng, XorShiftRng};
use std::io::Write;
use std::sync::{Arc, Barrier, Future};
use std::{fs, ptr};
use test::{Bencher, black_box};
use ffi::*;
use tempdir::TempDir;
use environment::*;
use error::*;
use ffi::*;
use flags::*;
use super::*;
use test_utils::*;
#[test]
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 db = env.open_db(None).unwrap();
@ -397,7 +398,7 @@ mod test {
#[test]
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 db = env.open_db(None).unwrap();
@ -418,7 +419,7 @@ mod test {
#[test]
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 db = env.open_db(None).unwrap();
@ -436,7 +437,7 @@ mod test {
#[test]
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 db = env.open_db(None).unwrap();
@ -456,7 +457,7 @@ mod test {
#[test]
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 db = env.open_db(None).unwrap();
@ -479,7 +480,7 @@ mod test {
#[test]
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)
.open(dir.path()).unwrap();
let db = env.create_db(Some("test"), DatabaseFlags::empty()).unwrap();
@ -500,7 +501,7 @@ mod test {
#[test]
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 n = 10usize; // Number of concurrent readers
@ -510,7 +511,7 @@ mod test {
let key = b"key";
let val = b"val";
for _ in range(0, n) {
for _ in 0..n {
let reader_env = env.clone();
let reader_barrier = barrier.clone();
@ -542,7 +543,7 @@ mod test {
#[test]
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 n = 10usize; // Number of concurrent writers
@ -551,7 +552,7 @@ mod test {
let key = "key";
let val = "val";
for i in range(0, n) {
for i in 0..n {
let writer_env = env.clone();
futures.push(Future::spawn(move|| {
@ -570,7 +571,7 @@ mod test {
let db = env.open_db(None).unwrap();
let txn = env.begin_ro_txn().unwrap();
for i in range(0, n) {
for i in 0..n {
assert_eq!(
format!("{}{}", val, i).as_bytes(),
txn.get(db, format!("{}{}", key, i).as_bytes()).unwrap());
@ -584,8 +585,7 @@ mod test {
let db = env.open_db(None).unwrap();
let txn = env.begin_ro_txn().unwrap();
let mut keys: Vec<String> = range(0, n).map(|n| get_key(n))
.collect::<Vec<_>>();
let mut keys: Vec<String> = (0..n).map(|n| get_key(n)).collect();
XorShiftRng::new_unseeded().shuffle(keys.as_mut_slice());
b.iter(|| {
@ -604,8 +604,7 @@ mod test {
let db = env.open_db(None).unwrap();
let _txn = env.begin_ro_txn().unwrap();
let mut keys: Vec<String> = range(0, n).map(|n| get_key(n))
.collect::<Vec<_>>();
let mut keys: Vec<String> = (0..n).map(|n| get_key(n)).collect();
XorShiftRng::new_unseeded().shuffle(keys.as_mut_slice());
let dbi = db.dbi();
@ -634,8 +633,7 @@ mod test {
let (_dir, env) = setup_bench_db(0);
let db = env.open_db(None).unwrap();
let mut items: Vec<(String, String)> = range(0, n).map(|n| (get_key(n), get_data(n)))
.collect::<Vec<_>>();
let mut items: Vec<(String, String)> = (0..n).map(|n| (get_key(n), get_data(n))).collect();
XorShiftRng::new_unseeded().shuffle(items.as_mut_slice());
b.iter(|| {
@ -653,8 +651,7 @@ mod test {
let (_dir, _env) = setup_bench_db(0);
let db = _env.open_db(None).unwrap();
let mut items: Vec<(String, String)> = range(0, n).map(|n| (get_key(n), get_data(n)))
.collect::<Vec<_>>();
let mut items: Vec<(String, String)> = (0..n).map(|n| (get_key(n), get_data(n))).collect();
XorShiftRng::new_unseeded().shuffle(items.as_mut_slice());
let dbi = db.dbi();

Write Preview
Loading…
Cancel
Save