finish skeleton for serializability check

Signed-off-by: Alex Chi <iskyzh@gmail.com>

mini-lsm-mvcc/src/mvcc.rs

@@ -1,22 +1,28 @@
+pub mod txn;
 mod watermark;
 
-use std::{ops::Bound, sync::Arc};
-
-use anyhow::Result;
-use bytes::Bytes;
-use parking_lot::Mutex;
-
-use crate::{
-    iterators::StorageIterator,
-    lsm_iterator::{FusedIterator, LsmIterator},
-    lsm_storage::LsmStorageInner,
+use std::{
+    collections::{BTreeMap, HashSet},
+    sync::{atomic::AtomicBool, Arc},
 };
 
-use self::watermark::Watermark;
+use crossbeam_skiplist::SkipMap;
+use parking_lot::Mutex;
+
+use crate::lsm_storage::LsmStorageInner;
+
+use self::{txn::Transaction, watermark::Watermark};
+
+pub(crate) struct CommittedTxnData {
+    pub(crate) key_hashes: Vec<u32>,
+    pub(crate) read_ts: u64,
+    pub(crate) commit_ts: u64,
+}
 
 pub(crate) struct LsmMvccInner {
     pub(crate) write_lock: Mutex<()>,
     pub(crate) ts: Arc<Mutex<(u64, Watermark)>>,
+    pub(crate) committed_txns: Arc<Mutex<BTreeMap<u64, CommittedTxnData>>>,
 }
 
 impl LsmMvccInner {
@@ -24,6 +30,7 @@ impl LsmMvccInner {
         Self {
             write_lock: Mutex::new(()),
             ts: Arc::new(Mutex::new((initial_ts, Watermark::new()))),
+            committed_txns: Arc::new(Mutex::new(BTreeMap::new())),
         }
     }
 
@@ -41,63 +48,20 @@ impl LsmMvccInner {
         ts.1.watermark().unwrap_or(ts.0)
     }
 
-    pub fn new_txn(&self, inner: Arc<LsmStorageInner>) -> Arc<Transaction> {
+    pub fn new_txn(&self, inner: Arc<LsmStorageInner>, serializable: bool) -> Arc<Transaction> {
         let mut ts = self.ts.lock();
         let read_ts = ts.0;
         ts.1.add_reader(read_ts);
-        Arc::new(Transaction { inner, read_ts })
-    }
-}
-
-pub struct Transaction {
-    read_ts: u64,
-    inner: Arc<LsmStorageInner>,
-}
-
-impl Transaction {
-    pub fn get(&self, key: &[u8]) -> Result<Option<Bytes>> {
-        self.inner.get_with_ts(key, self.read_ts)
-    }
-
-    pub fn scan(self: &Arc<Self>, lower: Bound<&[u8]>, upper: Bound<&[u8]>) -> Result<TxnIterator> {
-        Ok(TxnIterator {
-            _txn: self.clone(),
-            iter: self.inner.scan_with_ts(lower, upper, self.read_ts)?,
+        Arc::new(Transaction {
+            inner,
+            read_ts,
+            local_storage: Arc::new(SkipMap::new()),
+            committed: Arc::new(AtomicBool::new(false)),
+            key_hashes: if serializable {
+                Some(Mutex::new(HashSet::new()))
+            } else {
+                None
+            },
         })
     }
 }
-
-impl Drop for Transaction {
-    fn drop(&mut self) {
-        self.inner.mvcc().ts.lock().1.remove_reader(self.read_ts)
-    }
-}
-
-pub struct TxnIterator {
-    _txn: Arc<Transaction>,
-    iter: FusedIterator<LsmIterator>,
-}
-
-impl StorageIterator for TxnIterator {
-    type KeyType<'a> = &'a [u8] where Self: 'a;
-
-    fn value(&self) -> &[u8] {
-        self.iter.value()
-    }
-
-    fn key(&self) -> Self::KeyType<'_> {
-        self.iter.key()
-    }
-
-    fn is_valid(&self) -> bool {
-        self.iter.is_valid()
-    }
-
-    fn next(&mut self) -> Result<()> {
-        self.iter.next()
-    }
-
-    fn num_active_iterators(&self) -> usize {
-        self.iter.num_active_iterators()
-    }
-}