--- a/src/version.rs	Fri Sep 22 19:50:00 2017 +0200
+++ b/src/version.rs	Sun Sep 24 14:16:38 2017 +0200
@@ -47,9 +47,11 @@
     /// get returns the value for the specified key using the persistent tables contained in this
     /// Version.
     #[allow(unused_assignments)]
-    fn get(&self, key: &LookupKey) -> Result<Option<(Vec<u8>, GetStats)>> {
+    fn get<'a>(&self, key: InternalKey<'a>) -> Result<Option<(Vec<u8>, GetStats)>> {
         let levels = self.get_overlapping(key);
-        let ikey = key.internal_key();
+        let ikey = key;
+        let ukey = parse_internal_key(key).2;
+
         let mut stats = GetStats {
             file: None,
             level: 0,
@@ -71,8 +73,7 @@
                 // keys, we now need to check whether the found entry's user key is equal to the
                 // one we're looking for (get() just returns the next-bigger key).
                 if let Ok(Some((k, v))) = self.table_cache.borrow_mut().get(f.borrow().num, ikey) {
-                    if self.user_cmp.cmp(parse_internal_key(&k).2, key.user_key()) ==
-                       Ordering::Equal {
+                    if self.user_cmp.cmp(parse_internal_key(&k).2, ukey) == Ordering::Equal {
                         return Ok(Some((v, stats)));
                     }
                 }
@@ -82,10 +83,10 @@
     }
 
     /// get_overlapping returns the files overlapping key in each level.
-    fn get_overlapping(&self, key: &LookupKey) -> [Vec<FileMetaHandle>; NUM_LEVELS] {
+    fn get_overlapping<'a>(&self, key: InternalKey<'a>) -> [Vec<FileMetaHandle>; NUM_LEVELS] {
         let mut levels: [Vec<FileMetaHandle>; NUM_LEVELS] = Default::default();
-        let ikey = key.internal_key();
-        let ukey = key.user_key();
+        let ikey = key;
+        let ukey = parse_internal_key(key).2;
 
         let files = &self.files[0];
         levels[0].reserve(files.len());
@@ -169,7 +170,7 @@
     /// record_read_sample returns true if there is a new file to be compacted. It counts the
     /// number of files overlapping a key, and which level contains the first overlap.
     #[allow(unused_assignments)]
-    fn record_read_sample(&mut self, key: &LookupKey) -> bool {
+    pub fn record_read_sample<'a>(&mut self, key: InternalKey<'a>) -> bool {
         let levels = self.get_overlapping(key);
         let mut contained_in = 0;
         let mut i = 0;
@@ -709,7 +710,7 @@
               ("gbb".as_bytes(), 100, Ok(None))];
 
         for ref c in cases {
-            match v.get(&LookupKey::new(c.0, c.1)) {
+            match v.get(LookupKey::new(c.0, c.1).internal_key()) {
                 Ok(Some((val, _))) => assert_eq!(c.2.as_ref().unwrap().as_ref().unwrap(), &val),
                 Ok(None) => assert!(c.2.as_ref().unwrap().as_ref().is_none()),
                 Err(_) => assert!(c.2.is_err()),
@@ -795,15 +796,15 @@
         let k = LookupKey::new("aab".as_bytes(), MAX_SEQUENCE_NUMBER);
         let only_in_one = LookupKey::new("cax".as_bytes(), MAX_SEQUENCE_NUMBER);
 
-        assert!(!v.record_read_sample(&k));
-        assert!(!v.record_read_sample(&only_in_one));
+        assert!(!v.record_read_sample(k.internal_key()));
+        assert!(!v.record_read_sample(only_in_one.internal_key()));
 
         for fs in v.files.iter() {
             for f in fs {
                 f.borrow_mut().allowed_seeks = 0;
             }
         }
-        assert!(v.record_read_sample(&k));
+        assert!(v.record_read_sample(k.internal_key()));
     }
 
     #[test]