Mercurial > lbo > hg > sstable
changeset 31:db6eae79024a
Eradicate even more obsolete code
| author | Lewin Bormann <lbo@spheniscida.de> |
|---|---|
| date | Tue, 03 Jan 2017 20:05:19 +0100 |
| parents | cf6c50c9a5e7 |
| children | f4caa5af5b93 |
| files | src/cmp.rs src/filter.rs src/key_types.rs src/lib.rs src/table_builder.rs src/table_reader.rs |
| diffstat | 6 files changed, 27 insertions(+), 209 deletions(-) [+] |
line wrap: on
line diff
--- a/src/cmp.rs Tue Jan 03 19:59:01 2017 +0100 +++ b/src/cmp.rs Tue Jan 03 20:05:19 2017 +0100 @@ -1,8 +1,4 @@ -use key_types::{self, LookupKey}; -use types; - use std::cmp::Ordering; -use std::sync::Arc; /// Comparator trait, supporting types that can be nested (i.e., add additional functionality on /// top of an inner comparator) @@ -62,50 +58,9 @@ } } -/// Same as memtable_key_cmp, but for InternalKeys. -#[derive(Clone)] -pub struct InternalKeyCmp(pub Arc<Box<Cmp>>); - -impl Cmp for InternalKeyCmp { - fn cmp(&self, a: &[u8], b: &[u8]) -> Ordering { - let (_, seqa, keya) = key_types::parse_internal_key(a); - let (_, seqb, keyb) = key_types::parse_internal_key(b); - - match self.0.cmp(keya, keyb) { - Ordering::Less => Ordering::Less, - Ordering::Greater => Ordering::Greater, - // reverse comparison! - Ordering::Equal => seqb.cmp(&seqa), - } - } - - fn find_shortest_sep(&self, a: &[u8], b: &[u8]) -> Vec<u8> { - let (_, seqa, keya) = key_types::parse_internal_key(a); - let (_, _, keyb) = key_types::parse_internal_key(b); - - let sep: Vec<u8> = self.0.find_shortest_sep(keya, keyb); - - if sep.len() < keya.len() && self.0.cmp(keya, &sep) == Ordering::Less { - return LookupKey::new(&sep, types::MAX_SEQUENCE_NUMBER).internal_key().to_vec(); - } - - return LookupKey::new(&sep, seqa).internal_key().to_vec(); - } - - fn find_short_succ(&self, a: &[u8]) -> Vec<u8> { - let (_, seq, key) = key_types::parse_internal_key(a); - let succ: Vec<u8> = self.0.find_short_succ(key); - return LookupKey::new(&succ, seq).internal_key().to_vec(); - } -} - #[cfg(test)] mod tests { use super::*; - use key_types::LookupKey; - use types; - - use std::sync::Arc; #[test] fn test_cmp_defaultcmp_shortest_sep() { @@ -135,27 +90,4 @@ assert_eq!(DefaultCmp.find_short_succ(&[0xff, 0xff, 0xff]), &[0xff, 0xff, 0xff, 0xff]); } - - #[test] - fn test_cmp_internalkeycmp_shortest_sep() { - let cmp = InternalKeyCmp(Arc::new(Box::new(DefaultCmp))); - assert_eq!(cmp.find_shortest_sep(LookupKey::new("abcd".as_bytes(), 1).internal_key(), - LookupKey::new("abcf".as_bytes(), 2).internal_key()), - LookupKey::new("abce".as_bytes(), 1).internal_key()); - assert_eq!(cmp.find_shortest_sep(LookupKey::new("abc".as_bytes(), 1).internal_key(), - LookupKey::new("zzz".as_bytes(), 2).internal_key()), - LookupKey::new("b".as_bytes(), types::MAX_SEQUENCE_NUMBER).internal_key()); - assert_eq!(cmp.find_shortest_sep(LookupKey::new("abc".as_bytes(), 1).internal_key(), - LookupKey::new("acd".as_bytes(), 2).internal_key()), - LookupKey::new("abc".as_bytes(), 1).internal_key()); - assert_eq!(cmp.find_shortest_sep(LookupKey::new("abc".as_bytes(), 1).internal_key(), - LookupKey::new("abe".as_bytes(), 2).internal_key()), - LookupKey::new("abd".as_bytes(), 1).internal_key()); - assert_eq!(cmp.find_shortest_sep(LookupKey::new("".as_bytes(), 1).internal_key(), - LookupKey::new("".as_bytes(), 2).internal_key()), - LookupKey::new("".as_bytes(), 1).internal_key()); - assert_eq!(cmp.find_shortest_sep(LookupKey::new("abc".as_bytes(), 2).internal_key(), - LookupKey::new("abc".as_bytes(), 2).internal_key()), - LookupKey::new("abc".as_bytes(), 2).internal_key()); - } }
--- a/src/filter.rs Tue Jan 03 19:59:01 2017 +0100 +++ b/src/filter.rs Tue Jan 03 20:05:19 2017 +0100 @@ -215,7 +215,6 @@ #[cfg(test)] mod tests { use super::*; - use key_types::LookupKey; const _BITS_PER_KEY: u32 = 12; @@ -236,20 +235,6 @@ filter } - /// Creates a filter using the keys from input_data() but converted to InternalKey format. - fn create_internalkey_filter() -> Vec<u8> { - let fpol = InternalFilterPolicy::new(BloomPolicy::new(_BITS_PER_KEY)); - let input: Vec<Vec<u8>> = input_data() - .into_iter() - .map(|k| LookupKey::new(k, 123).internal_key().to_vec()) - .collect(); - let input_ = input.iter().map(|k| k.as_slice()).collect(); - - let filter = fpol.create_filter(&input_); - - filter - } - #[test] fn test_filter_bloom() { let f = create_filter(); @@ -260,12 +245,6 @@ } } - /// This test verifies that InternalFilterPolicy works correctly. - #[test] - fn test_filter_internal_keys_identical() { - assert_eq!(create_filter(), create_internalkey_filter()); - } - #[test] fn test_filter_bloom_hash() { let d1 = vec![0x62];
--- a/src/key_types.rs Tue Jan 03 19:59:01 2017 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,89 +0,0 @@ -use options::{CompressionType, int_to_compressiontype}; -use types::{ValueType, SequenceNumber}; - -use integer_encoding::{FixedInt, VarInt}; - -// The following typedefs are used to distinguish between the different key formats used internally -// by different modules. - -// TODO: At some point, convert those into actual types with conversions between them. That's a lot -// of boilerplate, but increases type safety. - -/// A UserKey is the actual key supplied by the calling application, without any internal -/// decorations. -pub type UserKey<'a> = &'a [u8]; - -/// An InternalKey consists of [key, tag], and is used as item type for Table iterators. -pub type InternalKey<'a> = &'a [u8]; - -/// A LookupKey is the first part of a memtable key, consisting of [keylen: varint32, key: *u8, -/// tag: u64] -/// keylen is the length of key plus 8 (for the tag; this for LevelDB compatibility) -#[derive(Clone, Debug)] -pub struct LookupKey { - key: Vec<u8>, - key_offset: usize, -} - -impl LookupKey { - #[allow(unused_assignments)] - pub fn new(k: &[u8], s: SequenceNumber) -> LookupKey { - let mut key = Vec::with_capacity(k.len() + k.len().required_space() + - <u64 as FixedInt>::required_space()); - let internal_keylen = k.len() + 8; - let mut i = 0; - - key.reserve(internal_keylen.required_space() + internal_keylen); - - key.resize(internal_keylen.required_space(), 0); - i += internal_keylen.encode_var(&mut key[i..]); - - key.extend_from_slice(k); - i += k.len(); - - key.resize(i + <u64 as FixedInt>::required_space(), 0); - (s << 8 | ValueType::TypeValue as u64).encode_fixed(&mut key[i..]); - i += <u64 as FixedInt>::required_space(); - - LookupKey { - key: key, - key_offset: k.len().required_space(), - } - } - - // Returns only key - #[allow(dead_code)] - pub fn user_key<'a>(&'a self) -> UserKey<'a> { - &self.key[self.key_offset..self.key.len() - 8] - } - - // Returns key+tag - pub fn internal_key<'a>(&'a self) -> InternalKey<'a> { - &self.key[self.key_offset..] - } -} - -/// Parses a tag into (type, sequence number) -pub fn parse_tag(tag: u64) -> (ValueType, u64) { - let seq = tag >> 8; - let typ = tag & 0xff; - - match typ { - 0 => (ValueType::TypeDeletion, seq), - 1 => (ValueType::TypeValue, seq), - _ => (ValueType::TypeValue, seq), - } -} - -/// Parse a key in InternalKey format. -pub fn parse_internal_key<'a>(ikey: InternalKey<'a>) -> (CompressionType, u64, UserKey<'a>) { - assert!(ikey.len() >= 8); - - let (ctype, seq) = parse_tag(FixedInt::decode_fixed(&ikey[ikey.len() - 8..])); - let ctype = int_to_compressiontype(ctype as u32).unwrap_or(CompressionType::CompressionNone); - - return (ctype, seq, &ikey[0..ikey.len() - 8]); -} - -#[cfg(test)] -mod tests {}
--- a/src/lib.rs Tue Jan 03 19:59:01 2017 +0100 +++ b/src/lib.rs Tue Jan 03 20:05:19 2017 +0100 @@ -3,17 +3,17 @@ mod block; mod blockhandle; -mod cmp; mod filter; mod filter_block; -mod key_types; mod types; +pub mod cmp; pub mod iterator; pub mod options; pub mod table_builder; pub mod table_reader; +pub use cmp::Cmp; pub use iterator::StandardComparator; pub use iterator::SSIterator; pub use options::{Options, ReadOptions};
--- a/src/table_builder.rs Tue Jan 03 19:59:01 2017 +0100 +++ b/src/table_builder.rs Tue Jan 03 20:05:19 2017 +0100 @@ -2,7 +2,6 @@ use blockhandle::BlockHandle; use filter::{BoxedFilterPolicy, NoFilterPolicy}; use filter_block::FilterBlockBuilder; -use key_types::InternalKey; use options::{CompressionType, Options}; use std::io::Write; @@ -96,8 +95,6 @@ /// TableBuilder is used for building a new SSTable. It groups entries into blocks, /// calculating checksums and bloom filters. -/// It's recommended that you use InternalFilterPolicy as FilterPol, as that policy extracts the -/// underlying user keys from the InternalKeys used as keys in the table. impl<'a, Dst: Write> TableBuilder<'a, Dst> { /// Create a new TableBuilder. Currently the best choice for `fpol` is `NoFilterPolicy` (mod /// filter; or use new_no_filter()) @@ -143,7 +140,7 @@ /// Writes an index entry for the current data_block where `next_key` is the first key of the /// next block. /// Calls write_block() for writing the block to disk. - fn write_data_block<'b>(&mut self, next_key: InternalKey<'b>) { + fn write_data_block(&mut self, next_key: &[u8]) { assert!(self.data_block.is_some()); let block = self.data_block.take().unwrap();
--- a/src/table_reader.rs Tue Jan 03 19:59:01 2017 +0100 +++ b/src/table_reader.rs Tue Jan 03 20:05:19 2017 +0100 @@ -2,7 +2,6 @@ use blockhandle::BlockHandle; use filter::BoxedFilterPolicy; use filter_block::FilterBlockReader; -use key_types::InternalKey; use options::{self, CompressionType, Options}; use table_builder::{self, Footer}; use iterator::SSIterator; @@ -165,13 +164,13 @@ /// Retrieve value from table. This function uses the attached filters, so is better suited if /// you frequently look for non-existing values (as it will detect the non-existence of an /// entry in a block without having to load the block). - pub fn get<'a>(&mut self, to: InternalKey<'a>) -> Option<Vec<u8>> { + pub fn get(&mut self, key: &[u8]) -> Option<Vec<u8>> { let mut iter = self.iter(); - iter.seek(to); + iter.seek(key); if let Some((k, v)) = iter.current() { - if k == to { Some(v) } else { None } + if k == key { Some(v) } else { None } } else { None } @@ -377,9 +376,9 @@ src[10] += 1; let mut table = Table::new(Options::default(), - Cursor::new(&src as &[u8]), - size, - BloomPolicy::new(4)) + Cursor::new(&src as &[u8]), + size, + BloomPolicy::new(4)) .unwrap(); assert!(table.filters.is_some()); @@ -410,9 +409,9 @@ let data = build_data(); let mut table = Table::new(Options::default(), - Cursor::new(&src as &[u8]), - size, - BloomPolicy::new(4)) + Cursor::new(&src as &[u8]), + size, + BloomPolicy::new(4)) .unwrap(); let mut iter = table.iter(); let mut i = 0; @@ -446,9 +445,9 @@ let (src, size) = build_table(); let mut table = Table::new(Options::default(), - Cursor::new(&src as &[u8]), - size, - BloomPolicy::new(4)) + Cursor::new(&src as &[u8]), + size, + BloomPolicy::new(4)) .unwrap(); let filter_reader = table.filters.clone().unwrap(); let mut iter = table.iter(); @@ -469,9 +468,9 @@ let (src, size) = build_table(); let mut table = Table::new(Options::default(), - Cursor::new(&src as &[u8]), - size, - BloomPolicy::new(4)) + Cursor::new(&src as &[u8]), + size, + BloomPolicy::new(4)) .unwrap(); let mut iter = table.iter(); @@ -503,9 +502,9 @@ let data = build_data(); let mut table = Table::new(Options::default(), - Cursor::new(&src as &[u8]), - size, - BloomPolicy::new(4)) + Cursor::new(&src as &[u8]), + size, + BloomPolicy::new(4)) .unwrap(); let mut iter = table.iter(); let mut i = 0; @@ -540,9 +539,9 @@ let (src, size) = build_table(); let mut table = Table::new(Options::default(), - Cursor::new(&src as &[u8]), - size, - BloomPolicy::new(4)) + Cursor::new(&src as &[u8]), + size, + BloomPolicy::new(4)) .unwrap(); let mut iter = table.iter(); @@ -561,9 +560,9 @@ let (src, size) = build_table(); let mut table = Table::new(Options::default(), - Cursor::new(&src as &[u8]), - size, - BloomPolicy::new(4)) + Cursor::new(&src as &[u8]), + size, + BloomPolicy::new(4)) .unwrap(); assert!(table.get("aaa".as_bytes()).is_none());