Mercurial > lbo > hg > leveldb-rs

changeset 471:22b3ba103397 v0.2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
chore(fmt): Run rustfmt
author Lewin Bormann <lbo@spheniscida.de>
date Sun, 26 May 2019 22:21:59 +0200
parents 58029576932d
children b9dd0ef8ccab
files examples/write-a-lot/src/main.rs src/cache.rs src/db_impl.rs src/db_iter.rs src/disk_env.rs src/env.rs src/filter.rs src/filter_block.rs src/log.rs src/mem_env.rs src/memtable.rs src/merging_iter.rs src/skipmap.rs src/snapshot.rs src/table_builder.rs src/table_cache.rs src/table_reader.rs src/test_util.rs src/types.rs src/version.rs src/version_set.rs src/write_batch.rs
diffstat 22 files changed, 167 insertions(+), 126 deletions(-) [+]
line wrap: on
line diff
--- a/examples/write-a-lot/src/main.rs	Sun May 26 22:20:48 2019 +0200
+++ b/examples/write-a-lot/src/main.rs	Sun May 26 22:21:59 2019 +0200
@@ -1,10 +1,10 @@
 extern crate rand;
 extern crate rusty_leveldb;
 
+use rand::Rng;
 use rusty_leveldb::CompressionType;
+use rusty_leveldb::Options;
 use rusty_leveldb::DB;
-use rusty_leveldb::Options;
-use rand::Rng;
 
 use std::error::Error;
 use std::iter::FromIterator;
--- a/src/cache.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/cache.rs	Sun May 26 22:21:59 2019 +0200
@@ -239,8 +239,8 @@
 
 #[cfg(test)]
 mod tests {
+    use super::LRUList;
     use super::*;
-    use super::LRUList;
 
     fn make_key(a: u8, b: u8, c: u8) -> CacheKey {
         [a, b, c, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
--- a/src/db_impl.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/db_impl.rs	Sun May 26 22:21:59 2019 +0200
@@ -10,19 +10,23 @@
 use error::{err, Result, StatusCode};
 use filter::{BoxedFilterPolicy, InternalFilterPolicy};
 use infolog::Logger;
+use key_types::{parse_internal_key, InternalKey, LookupKey, ValueType};
 use log::{LogReader, LogWriter};
-use key_types::{parse_internal_key, InternalKey, LookupKey, ValueType};
 use memtable::MemTable;
 use merging_iter::MergingIter;
 use options::Options;
 use snapshot::{Snapshot, SnapshotList};
 use table_builder::TableBuilder;
 use table_cache::{table_file_name, TableCache};
-use types::{parse_file_name, share, FileMetaData, FileNum, FileType, LdbIterator, SequenceNumber,
-            Shared, MAX_SEQUENCE_NUMBER, NUM_LEVELS};
+use types::{
+    parse_file_name, share, FileMetaData, FileNum, FileType, LdbIterator, SequenceNumber, Shared,
+    MAX_SEQUENCE_NUMBER, NUM_LEVELS,
+};
+use version::Version;
 use version_edit::VersionEdit;
-use version_set::{manifest_file_name, read_current_file, set_current_file, Compaction, VersionSet};
-use version::Version;
+use version_set::{
+    manifest_file_name, read_current_file, set_current_file, Compaction, VersionSet,
+};
 use write_batch::WriteBatch;
 
 use std::cmp::Ordering;
@@ -108,7 +112,8 @@
         // Create log file if an old one is not being reused.
         if db.log.is_none() {
             let lognum = db.vset.borrow_mut().new_file_number();
-            let logfile = db.opt
+            let logfile = db
+                .opt
                 .env
                 .open_writable_file(Path::new(&log_file_name(&db.name, lognum)))?;
             ve.set_log_num(lognum);
@@ -225,8 +230,7 @@
         let cmp: Rc<Box<Cmp>> = self.opt.cmp.clone();
 
         let mut logreader = LogReader::new(
-            logfile,
-            // checksum=
+            logfile, // checksum=
             true,
         );
         log!(self.opt.log, "Recovering log file {:?}", filename);
@@ -553,7 +557,8 @@
         } else {
             // Create new memtable.
             let logn = self.vset.borrow_mut().new_file_number();
-            let logf = self.opt
+            let logf = self
+                .opt
                 .env
                 .open_writable_file(Path::new(&log_file_name(&self.name, logn)));
             if logf.is_err() {
@@ -614,7 +619,8 @@
 
         for l in 0..max_level + 1 {
             loop {
-                let c_ = self.vset
+                let c_ = self
+                    .vset
                     .borrow_mut()
                     .compact_range(l, &ifrom, iend.internal_key());
                 if let Some(c) = c_ {
@@ -731,7 +737,8 @@
                 num,
                 e
             );
-            let _ = self.opt
+            let _ = self
+                .opt
                 .env
                 .delete(Path::new(&table_file_name(&self.name, num)));
             return Err(e);
@@ -814,7 +821,8 @@
             }
             // Entry is deletion; no older version is observable by any snapshot; and all entries
             // in compacted levels with smaller sequence numbers will
-            if ktyp == ValueType::TypeDeletion && seq <= cs.smallest_seq
+            if ktyp == ValueType::TypeDeletion
+                && seq <= cs.smallest_seq
                 && cs.compaction.is_base_level_for(ukey)
             {
                 last_seq_for_key = seq;
@@ -1114,13 +1122,13 @@
 
 #[cfg(test)]
 mod tests {
+    use super::testutil::{build_db, set_file_to_compact};
     use super::*;
-    use super::testutil::{build_db, set_file_to_compact};
 
     use error::Status;
-    use options;
     use key_types::LookupKey;
     use mem_env::MemEnv;
+    use options;
     use test_util::LdbIteratorIter;
     use version::testutil::make_version;
 
--- a/src/db_iter.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/db_iter.rs	Sun May 26 22:21:59 2019 +0200
@@ -287,10 +287,10 @@
 #[cfg(test)]
 mod tests {
     use super::*;
-    use types::{current_key_val, Direction};
+    use db_impl::testutil::*;
+    use db_impl::DB;
     use test_util::LdbIteratorIter;
-    use db_impl::DB;
-    use db_impl::testutil::*;
+    use types::{current_key_val, Direction};
 
     use std::collections::HashMap;
     use std::collections::HashSet;
@@ -303,10 +303,10 @@
 
         // keys and values come from make_version(); they are each the latest entry.
         let keys: &[&[u8]] = &[
-            b"aaa", b"aab", b"aax", b"aba", b"bab", b"bba", b"cab", b"cba"
+            b"aaa", b"aab", b"aax", b"aba", b"bab", b"bba", b"cab", b"cba",
         ];
         let vals: &[&[u8]] = &[
-            b"val1", b"val2", b"val2", b"val3", b"val4", b"val5", b"val2", b"val3"
+            b"val1", b"val2", b"val2", b"val3", b"val4", b"val5", b"val2", b"val3",
         ];
 
         for (k, v) in keys.iter().zip(vals.iter()) {
@@ -335,10 +335,10 @@
 
         // keys and values come from make_version(); they are each the latest entry.
         let keys: &[&[u8]] = &[
-            b"aaa", b"aab", b"aax", b"aba", b"bab", b"bba", b"cab", b"cba"
+            b"aaa", b"aab", b"aax", b"aba", b"bab", b"bba", b"cab", b"cba",
         ];
         let vals: &[&[u8]] = &[
-            b"val1", b"val2", b"val2", b"val3", b"val4", b"val5", b"val2", b"val3"
+            b"val1", b"val2", b"val2", b"val3", b"val4", b"val5", b"val2", b"val3",
         ];
 
         // This specifies the direction that the iterator should move to. Based on this, an index
@@ -387,7 +387,7 @@
         // gca is the deleted entry.
         let keys: &[&[u8]] = &[b"aab", b"aaa", b"cab", b"eaa", b"aaa", b"iba", b"fba"];
         let vals: &[&[u8]] = &[
-            b"val2", b"val1", b"val2", b"val1", b"val1", b"val2", b"val3"
+            b"val2", b"val1", b"val2", b"val1", b"val1", b"val2", b"val3",
         ];
 
         for (k, v) in keys.iter().zip(vals.iter()) {
@@ -469,7 +469,8 @@
                     (b"xx4".to_vec(), b"222".to_vec()),
                     (b"aaa".to_vec(), b"val1".to_vec()),
                     (b"cab".to_vec(), b"val2".to_vec()),
-                ].into_iter(),
+                ]
+                .into_iter(),
             );
             let non_existing: HashSet<Vec<u8>> = HashSet::from_iter(
                 vec![b"gca".to_vec(), b"xx2".to_vec(), b"xx5".to_vec()].into_iter(),
--- a/src/disk_env.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/disk_env.rs	Sun May 26 22:21:59 2019 +0200
@@ -43,10 +43,12 @@
 // error conversion using std::convert::From.
 impl Env for PosixDiskEnv {
     fn open_sequential_file(&self, p: &Path) -> Result<Box<Read>> {
-        Ok(Box::new(fs::OpenOptions::new()
-            .read(true)
-            .open(p)
-            .map_err(|e| map_err_with_name("open (seq)", p, e))?))
+        Ok(Box::new(
+            fs::OpenOptions::new()
+                .read(true)
+                .open(p)
+                .map_err(|e| map_err_with_name("open (seq)", p, e))?,
+        ))
     }
     fn open_random_access_file(&self, p: &Path) -> Result<Box<RandomAccess>> {
         Ok(fs::OpenOptions::new()
@@ -59,20 +61,24 @@
             .map_err(|e| map_err_with_name("open (randomaccess)", p, e))?)
     }
     fn open_writable_file(&self, p: &Path) -> Result<Box<Write>> {
-        Ok(Box::new(fs::OpenOptions::new()
-            .create(true)
-            .write(true)
-            .append(false)
-            .open(p)
-            .map_err(|e| map_err_with_name("open (write)", p, e))?))
+        Ok(Box::new(
+            fs::OpenOptions::new()
+                .create(true)
+                .write(true)
+                .append(false)
+                .open(p)
+                .map_err(|e| map_err_with_name("open (write)", p, e))?,
+        ))
     }
     fn open_appendable_file(&self, p: &Path) -> Result<Box<Write>> {
-        Ok(Box::new(fs::OpenOptions::new()
-            .create(true)
-            .write(true)
-            .append(true)
-            .open(p)
-            .map_err(|e| map_err_with_name("open (append)", p, e))?))
+        Ok(Box::new(
+            fs::OpenOptions::new()
+                .create(true)
+                .write(true)
+                .append(true)
+                .open(p)
+                .map_err(|e| map_err_with_name("open (append)", p, e))?,
+        ))
     }
 
     fn exists(&self, p: &Path) -> Result<bool> {
@@ -279,9 +285,11 @@
         let env = PosixDiskEnv::new();
 
         assert!(env.mkdir(dirname).is_ok());
-        assert!(env.open_writable_file(
-            String::from_iter(vec![d.to_string(), "f1.txt".to_string()].into_iter()).as_ref()
-        ).is_ok());
+        assert!(env
+            .open_writable_file(
+                String::from_iter(vec![d.to_string(), "f1.txt".to_string()].into_iter()).as_ref()
+            )
+            .is_ok());
         assert_eq!(env.children(dirname).unwrap().len(), 1);
         assert!(env.rmdir(dirname).is_ok());
     }
--- a/src/env.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/env.rs	Sun May 26 22:21:59 2019 +0200
@@ -3,8 +3,8 @@
 
 use error::Result;
 
+use std::fs::File;
 use std::io::prelude::*;
-use std::fs::File;
 use std::os::unix::fs::FileExt;
 use std::path::{Path, PathBuf};
 
--- a/src/filter.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/filter.rs	Sun May 26 22:21:59 2019 +0200
@@ -247,7 +247,8 @@
             "xxx111xxx222".as_bytes(),
             "ab00cd00ab".as_bytes(),
             "908070605040302010".as_bytes(),
-        ].iter()
+        ]
+        .iter()
         {
             offs.push(concat.len());
             concat.extend_from_slice(d);
--- a/src/filter_block.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/filter_block.rs	Sun May 26 22:21:59 2019 +0200
@@ -165,10 +165,10 @@
 
 #[cfg(test)]
 mod tests {
-    use filter::BloomPolicy;
+    use super::get_filter_index;
+    use super::FILTER_BASE_LOG2;
     use super::*;
-    use super::FILTER_BASE_LOG2;
-    use super::get_filter_index;
+    use filter::BloomPolicy;
 
     #[test]
     fn test_filter_index() {
--- a/src/log.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/log.rs	Sun May 26 22:21:59 2019 +0200
@@ -150,10 +150,9 @@
         loop {
             if self.blocksize - self.blk_off < HEADER_SIZE {
                 // skip to next block
-                try!(
-                    self.src
-                        .read(&mut self.head_scratch[0..self.blocksize - self.blk_off])
-                );
+                try!(self
+                    .src
+                    .read(&mut self.head_scratch[0..self.blocksize - self.blk_off]));
                 self.blk_off = 0;
             }
 
@@ -171,10 +170,9 @@
             typ = self.head_scratch[6];
 
             dst.resize(dst_offset + length as usize, 0);
-            bytes_read = try!(
-                self.src
-                    .read(&mut dst[dst_offset..dst_offset + length as usize])
-            );
+            bytes_read = try!(self
+                .src
+                .read(&mut dst[dst_offset..dst_offset + length as usize]));
             self.blk_off += bytes_read;
 
             if self.checksums
--- a/src/mem_env.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/mem_env.rs	Sun May 26 22:21:59 2019 +0200
@@ -4,8 +4,8 @@
 use env_common::{micros, sleep_for};
 use error::{err, Result, StatusCode};
 
+use std::collections::hash_map::Entry;
 use std::collections::HashMap;
-use std::collections::hash_map::Entry;
 use std::io::{self, Read, Write};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
@@ -553,16 +553,20 @@
         assert!(fs.unlock_(lock).is_ok());
 
         // Rogue operation.
-        assert!(fs.unlock_(env::FileLock {
-            id: "/a/lock".to_string(),
-        }).is_err());
+        assert!(fs
+            .unlock_(env::FileLock {
+                id: "/a/lock".to_string(),
+            })
+            .is_err());
 
         // Non-existent files.
         let p2 = Path::new("/a/lock2");
         assert!(fs.lock_(p2).is_ok());
-        assert!(fs.unlock_(env::FileLock {
-            id: "/a/lock2".to_string(),
-        }).is_ok());
+        assert!(fs
+            .unlock_(env::FileLock {
+                id: "/a/lock2".to_string(),
+            })
+            .is_ok());
     }
 
     #[test]
--- a/src/memtable.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/memtable.rs	Sun May 26 22:21:59 2019 +0200
@@ -1,8 +1,8 @@
-use key_types::{LookupKey, UserKey};
 use cmp::{Cmp, MemtableKeyCmp};
 use key_types::{build_memtable_key, parse_internal_key, parse_memtable_key, ValueType};
+use key_types::{LookupKey, UserKey};
+use skipmap::{SkipMap, SkipMapIter};
 use types::{current_key_val, LdbIterator, SequenceNumber};
-use skipmap::{SkipMap, SkipMapIter};
 
 use std::rc::Rc;
 
@@ -155,8 +155,8 @@
 mod tests {
     use super::*;
     use key_types::*;
+    use options;
     use test_util::{test_iterator_properties, LdbIteratorIter};
-    use options;
 
     #[test]
     fn test_shift_left() {
--- a/src/merging_iter.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/merging_iter.rs	Sun May 26 22:21:59 2019 +0200
@@ -199,9 +199,9 @@
     use super::*;
 
     use cmp::DefaultCmp;
+    use skipmap::tests;
     use test_util::{test_iterator_properties, LdbIteratorIter, TestLdbIter};
     use types::{current_key_val, LdbIterator};
-    use skipmap::tests;
 
     #[test]
     fn test_merging_one() {
--- a/src/skipmap.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/skipmap.rs	Sun May 26 22:21:59 2019 +0200
@@ -1,6 +1,6 @@
 use cmp::{Cmp, MemtableKeyCmp};
+use rand::{Rng, SeedableRng, StdRng};
 use types::LdbIterator;
-use rand::{Rng, SeedableRng, StdRng};
 
 use std::cell::RefCell;
 use std::cmp::Ordering;
@@ -251,8 +251,10 @@
             }
         }
 
-        let added_mem = size_of::<Node>() + size_of::<Option<*mut Node>>() * new.skips.len()
-            + new.key.len() + new.value.len();
+        let added_mem = size_of::<Node>()
+            + size_of::<Option<*mut Node>>() * new.skips.len()
+            + new.key.len()
+            + new.value.len();
         self.approx_mem += added_mem;
         self.len += 1;
 
@@ -336,7 +338,8 @@
     fn prev(&mut self) -> bool {
         // Going after the original implementation here; we just seek to the node before current().
         if self.valid() {
-            if let Some(prev) = self.map
+            if let Some(prev) = self
+                .map
                 .borrow()
                 .get_next_smaller(unsafe { &(*self.current).key })
             {
@@ -355,9 +358,9 @@
 pub mod tests {
     use super::*;
     use cmp::MemtableKeyCmp;
+    use options;
     use test_util::{test_iterator_properties, LdbIteratorIter};
     use types::current_key_val;
-    use options;
 
     pub fn make_skipmap() -> SkipMap {
         let mut skm = SkipMap::new(options::for_test().cmp);
@@ -412,12 +415,11 @@
                 .key,
             "abf".as_bytes().to_vec()
         );
-        assert!(
-            skm.map
-                .borrow()
-                .get_greater_or_equal(&"ab{".as_bytes().to_vec())
-                .is_none()
-        );
+        assert!(skm
+            .map
+            .borrow()
+            .get_greater_or_equal(&"ab{".as_bytes().to_vec())
+            .is_none());
         assert_eq!(
             skm.map
                 .borrow()
@@ -444,12 +446,11 @@
                 .as_slice(),
             "abc".as_bytes()
         );
-        assert!(
-            skm.map
-                .borrow()
-                .get_next_smaller(&"ab0".as_bytes())
-                .is_none()
-        );
+        assert!(skm
+            .map
+            .borrow()
+            .get_next_smaller(&"ab0".as_bytes())
+            .is_none());
         assert_eq!(
             skm.map
                 .borrow()
--- a/src/snapshot.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/snapshot.rs	Sun May 26 22:21:59 2019 +0200
@@ -78,7 +78,8 @@
     /// oldest returns the lowest sequence number of all snapshots. It returns 0 if no snapshots
     /// are present.
     pub fn oldest(&self) -> SequenceNumber {
-        let oldest = self.inner
+        let oldest = self
+            .inner
             .borrow()
             .map
             .iter()
--- a/src/table_builder.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/table_builder.rs	Sun May 26 22:21:59 2019 +0200
@@ -228,7 +228,8 @@
         // If there's a pending data block, write it
         if self.data_block.as_ref().unwrap().entries() > 0 {
             // Find a key reliably past the last key
-            let key_past_last = self.opt
+            let key_past_last = self
+                .opt
                 .cmp
                 .find_short_succ(self.data_block.as_ref().unwrap().last_key());
             self.write_data_block(&key_past_last)?;
--- a/src/table_cache.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/table_cache.rs	Sun May 26 22:21:59 2019 +0200
@@ -11,9 +11,9 @@
 
 use integer_encoding::FixedIntWriter;
 
+use std::convert::AsRef;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
-use std::convert::AsRef;
 
 pub fn table_file_name<P: AsRef<Path>>(name: P, num: FileNum) -> PathBuf {
     assert!(num > 0);
--- a/src/table_reader.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/table_reader.rs	Sun May 26 22:21:59 2019 +0200
@@ -362,11 +362,11 @@
 #[cfg(test)]
 mod tests {
     use filter::BloomPolicy;
+    use key_types::LookupKey;
     use options::{self, CompressionType};
     use table_builder::TableBuilder;
     use test_util::{test_iterator_properties, LdbIteratorIter};
     use types::{current_key_val, LdbIterator};
-    use key_types::LookupKey;
 
     use super::*;
 
@@ -705,12 +705,10 @@
             assert_eq!((k.to_vec(), v.to_vec()), table.get(k).unwrap().unwrap());
         }
 
-        assert!(
-            table
-                .get(LookupKey::new(b"abc", 1000).internal_key())
-                .unwrap()
-                .is_some()
-        );
+        assert!(table
+            .get(LookupKey::new(b"abc", 1000).internal_key())
+            .unwrap()
+            .is_some());
 
         let mut iter = table.iter();
 
--- a/src/test_util.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/test_util.rs	Sun May 26 22:21:59 2019 +0200
@@ -1,5 +1,5 @@
+use cmp::{Cmp, DefaultCmp};
 use types::{current_key_val, LdbIterator};
-use cmp::{Cmp, DefaultCmp};
 
 use std::cmp::Ordering;
 
--- a/src/types.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/types.rs	Sun May 26 22:21:59 2019 +0200
@@ -3,8 +3,8 @@
 use error::{err, Result, StatusCode};
 
 use std::cell::RefCell;
+use std::path::Path;
 use std::rc::Rc;
-use std::path::Path;
 
 pub const NUM_LEVELS: usize = 7;
 
--- a/src/version.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/version.rs	Sun May 26 22:21:59 2019 +0200
@@ -146,7 +146,8 @@
             if fs.is_empty() {
                 continue;
             }
-            let filedesc: Vec<(FileNum, usize)> = fs.iter()
+            let filedesc: Vec<(FileNum, usize)> = fs
+                .iter()
                 .map(|f| (f.borrow().num, f.borrow().size))
                 .collect();
             let desc = format!(
@@ -428,7 +429,8 @@
         }
 
         // Initialize iterator or load next table.
-        if let Ok(tbl) = self.cache
+        if let Ok(tbl) = self
+            .cache
             .borrow_mut()
             .get_table(self.files[self.current_ix].borrow().num)
         {
@@ -447,7 +449,8 @@
     }
     fn seek(&mut self, key: &[u8]) {
         if let Some(ix) = find_file(&self.cmp, &self.files, key) {
-            if let Ok(tbl) = self.cache
+            if let Ok(tbl) = self
+                .cache
                 .borrow_mut()
                 .get_table(self.files[ix].borrow().num)
             {
@@ -604,7 +607,8 @@
         startseq: u64,
         num: FileNum,
     ) -> FileMetaHandle {
-        let dst = me.open_writable_file(Path::new(&table_file_name("db", num)))
+        let dst = me
+            .open_writable_file(Path::new(&table_file_name("db", num)))
             .unwrap();
         let mut seq = startseq;
         let keys: Vec<Vec<u8>> = contents
@@ -715,8 +719,8 @@
 
 #[cfg(test)]
 mod tests {
+    use super::testutil::*;
     use super::*;
-    use super::testutil::*;
 
     use cmp::DefaultCmp;
     use error::Result;
@@ -857,7 +861,8 @@
             ("000".as_bytes(), "abc".as_bytes(), 0),
             ("gab".as_bytes(), "hhh".as_bytes(), 1),
             ("000".as_bytes(), "111".as_bytes(), 2),
-        ].iter()
+        ]
+        .iter()
         {
             assert_eq!(c.2, v.pick_memtable_output_level(c.0, c.1));
         }
--- a/src/version_set.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/version_set.rs	Sun May 26 22:21:59 2019 +0200
@@ -6,8 +6,9 @@
 use merging_iter::MergingIter;
 use options::Options;
 use table_cache::TableCache;
-use types::{parse_file_name, share, FileMetaData, FileNum, FileType, LdbIterator, Shared,
-            NUM_LEVELS};
+use types::{
+    parse_file_name, share, FileMetaData, FileNum, FileType, LdbIterator, Shared, NUM_LEVELS,
+};
 use version::{new_version_iter, total_size, FileMetaHandle, Version};
 use version_edit::VersionEdit;
 
@@ -142,7 +143,8 @@
         }
         let grandparents = self.grandparents.as_ref().unwrap();
         while self.grandparent_ix < grandparents.len()
-            && self.icmp
+            && self
+                .icmp
                 .cmp(k, &grandparents[self.grandparent_ix].borrow().largest)
                 == Ordering::Greater
         {
@@ -294,7 +296,8 @@
 
             for f in &current.files[level] {
                 if self.compaction_ptrs[level].is_empty()
-                    || self.cmp
+                    || self
+                        .cmp
                         .cmp(&f.borrow().largest, &self.compaction_ptrs[level])
                         == Ordering::Greater
                 {
@@ -336,11 +339,12 @@
         to: InternalKey<'b>,
     ) -> Option<Compaction> {
         assert!(self.current.is_some());
-        let mut inputs = self.current.as_ref().unwrap().borrow().overlapping_inputs(
-            level,
-            from,
-            to,
-        );
+        let mut inputs = self
+            .current
+            .as_ref()
+            .unwrap()
+            .borrow()
+            .overlapping_inputs(level, from, to);
         if inputs.is_empty() {
             return None;
         }
@@ -503,9 +507,9 @@
         if self.descriptor_log.is_none() {
             let descname = manifest_file_name(&self.dbname, self.manifest_num);
             edit.set_next_file(self.next_file_num);
-            self.descriptor_log = Some(LogWriter::new(self.opt
-                .env
-                .open_writable_file(Path::new(&descname))?));
+            self.descriptor_log = Some(LogWriter::new(
+                self.opt.env.open_writable_file(Path::new(&descname))?,
+            ));
             self.write_snapshot()?;
         }
 
@@ -566,7 +570,10 @@
         let descfilename = self.dbname.join(current);
         let mut builder = Builder::new();
         {
-            let mut descfile = self.opt.env.open_sequential_file(Path::new(&descfilename))?;
+            let mut descfile = self
+                .opt
+                .env
+                .open_sequential_file(Path::new(&descfilename))?;
             let mut logreader = LogReader::new(
                 &mut descfile,
                 // checksum=
@@ -681,7 +688,8 @@
             }
 
             assert!(self.descriptor_log.is_none());
-            let s = self.opt
+            let s = self
+                .opt
                 .env
                 .open_appendable_file(Path::new(current_manifest_path));
             if let Ok(f) = s {
@@ -1243,7 +1251,8 @@
             // compact level 0 with a partial range.
             let from = LookupKey::new("000".as_bytes(), 1000);
             let to = LookupKey::new("ab".as_bytes(), 1010);
-            let c = vs.compact_range(0, from.internal_key(), to.internal_key())
+            let c = vs
+                .compact_range(0, from.internal_key(), to.internal_key())
                 .unwrap();
             assert_eq!(2, c.inputs[0].len());
             assert_eq!(1, c.inputs[1].len());
@@ -1252,7 +1261,8 @@
             // compact level 0, but entire range of keys in version.
             let from = LookupKey::new("000".as_bytes(), 1000);
             let to = LookupKey::new("zzz".as_bytes(), 1010);
-            let c = vs.compact_range(0, from.internal_key(), to.internal_key())
+            let c = vs
+                .compact_range(0, from.internal_key(), to.internal_key())
                 .unwrap();
             assert_eq!(2, c.inputs[0].len());
             assert_eq!(1, c.inputs[1].len());
@@ -1266,7 +1276,8 @@
             // Expand input range on higher level.
             let from = LookupKey::new("dab".as_bytes(), 1000);
             let to = LookupKey::new("eab".as_bytes(), 1010);
-            let c = vs.compact_range(1, from.internal_key(), to.internal_key())
+            let c = vs
+                .compact_range(1, from.internal_key(), to.internal_key())
                 .unwrap();
             assert_eq!(3, c.inputs[0].len());
             assert_eq!(1, c.inputs[1].len());
@@ -1280,7 +1291,8 @@
             // is_trivial_move
             let from = LookupKey::new("fab".as_bytes(), 1000);
             let to = LookupKey::new("fba".as_bytes(), 1010);
-            let mut c = vs.compact_range(2, from.internal_key(), to.internal_key())
+            let mut c = vs
+                .compact_range(2, from.internal_key(), to.internal_key())
                 .unwrap();
             // pretend it's not manual
             c.manual = false;
@@ -1290,7 +1302,8 @@
             let from = LookupKey::new("000".as_bytes(), 1000);
             let to = LookupKey::new("zzz".as_bytes(), 1010);
             let mid = LookupKey::new("abc".as_bytes(), 1010);
-            let mut c = vs.compact_range(0, from.internal_key(), to.internal_key())
+            let mut c = vs
+                .compact_range(0, from.internal_key(), to.internal_key())
                 .unwrap();
             assert!(!c.should_stop_before(from.internal_key()));
             assert!(!c.should_stop_before(mid.internal_key()));
@@ -1299,7 +1312,8 @@
             // is_base_level_for
             let from = LookupKey::new("000".as_bytes(), 1000);
             let to = LookupKey::new("zzz".as_bytes(), 1010);
-            let mut c = vs.compact_range(0, from.internal_key(), to.internal_key())
+            let mut c = vs
+                .compact_range(0, from.internal_key(), to.internal_key())
                 .unwrap();
             assert!(c.is_base_level_for("aaa".as_bytes()));
             assert!(!c.is_base_level_for("hac".as_bytes()));
@@ -1307,7 +1321,8 @@
             // input/add_input_deletions
             let from = LookupKey::new("000".as_bytes(), 1000);
             let to = LookupKey::new("zzz".as_bytes(), 1010);
-            let mut c = vs.compact_range(0, from.internal_key(), to.internal_key())
+            let mut c = vs
+                .compact_range(0, from.internal_key(), to.internal_key())
                 .unwrap();
             for inp in &[(0, 0, 1), (0, 1, 2), (1, 0, 3)] {
                 let f = &c.inputs[inp.0][inp.1];
--- a/src/write_batch.rs	Sun May 26 22:20:48 2019 +0200
+++ b/src/write_batch.rs	Sun May 26 22:21:59 2019 +0200
@@ -1,7 +1,7 @@
+use integer_encoding::{FixedInt, VarInt, VarIntWriter};
 use key_types::ValueType;
 use memtable::MemTable;
 use types::SequenceNumber;
-use integer_encoding::{FixedInt, VarInt, VarIntWriter};
 
 use std::io::Write;