feat: add sstable

Author: adambcomer

src/lib.rs

@@ -1,9 +1,6 @@
 pub mod database;
 mod mem_table;
+mod sstable;
 mod utils;
 mod wal;
 mod wal_iterator;
-
-// mod table;
-// mod table_manager;
-// mod utils;

src/sstable.rs

@@ -0,0 +1,191 @@
+use std::fs::{File, OpenOptions};
+use std::io::{self, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write};
+use std::path::Path;
+use std::time::{SystemTime, UNIX_EPOCH};
+use std::{u8, usize};
+
+use crate::mem_table::MemTable;
+
+pub struct SSTableEntry {
+    key: Vec<u8>,
+    value: Option<Vec<u8>>,
+    timestamp: u128,
+}
+
+pub struct SSTable {
+    file: BufReader<File>,
+    offsets: Vec<u64>,
+    low_key: Vec<u8>,
+    high_key: Vec<u8>,
+}
+
+impl SSTable {
+    pub fn new(memtable: &MemTable, level: usize, dir: &Path) -> io::Result<SSTable> {
+        let timestamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_micros();
+
+        let path = Path::new(dir).join(format!("{}/{}.sstable", level, timestamp.to_string()));
+        let file = OpenOptions::new().append(true).create(true).open(&path)?;
+        let mut file = BufWriter::new(file);
+
+        let mut offsets = Vec::new();
+        let mut offset = 0;
+        for item in memtable.entries() {
+            offsets.push(offset as u64);
+
+            file.write_all(&item.key.len().to_le_bytes())?;
+            file.write_all(&item.key)?;
+            file.write_all(&(item.deleted as u8).to_le_bytes())?;
+            if !item.deleted {
+                file.write_all(&item.value.as_ref().unwrap().len().to_le_bytes())?;
+                file.write_all(item.value.as_ref().unwrap())?;
+            }
+            file.write_all(&timestamp.to_le_bytes())?;
+
+            offset += size_of::<usize>()
+                + size_of::<usize>()
+                + size_of::<u8>()
+                + size_of::<u128>()
+                + item.key.len()
+                + item.value.as_ref().unwrap_or(&vec![]).len();
+        }
+
+        file.flush()?;
+
+        let file = OpenOptions::new().read(true).open(&path)?;
+        let file = BufReader::new(file);
+
+        Ok(SSTable {
+            file,
+            offsets,
+            low_key: memtable.entries().first().unwrap().key.clone(),
+            high_key: memtable.entries().last().unwrap().key.clone(),
+        })
+    }
+
+    pub fn load_from_path(path: &Path) -> io::Result<SSTable> {
+        let file = OpenOptions::new().read(true).open(&path)?;
+        let mut file = BufReader::new(file);
+
+        let mut offsets = Vec::new();
+        let mut offset = 0;
+        while file.fill_buf()?.len() > 0 {
+            offsets.push(offset as u64);
+
+            let mut buf = [0u8; size_of::<usize>()];
+            file.read_exact(&mut buf)?;
+
+            let key_len = usize::from_le_bytes(buf);
+            file.consume(key_len);
+
+            let mut buf = [0u8; size_of::<u8>()];
+            file.read_exact(&mut buf)?;
+
+            let mut val_len = 0;
+            if buf[0] != 0 {
+                let mut buf = [0u8; size_of::<usize>()];
+                file.read_exact(&mut buf)?;
+
+                val_len = usize::from_le_bytes(buf);
+                file.consume(key_len);
+            }
+
+            file.consume(size_of::<u128>());
+
+            offset += size_of::<usize>()
+                + size_of::<usize>()
+                + size_of::<u8>()
+                + size_of::<u128>()
+                + key_len
+                + val_len;
+        }
+
+        file.seek(SeekFrom::Start(0))?;
+
+        let mut buf = [0u8; size_of::<usize>()];
+        file.read_exact(&mut buf)?;
+
+        let key_len = usize::from_le_bytes(buf);
+        let mut low_key = vec![0u8; key_len];
+        file.read_exact(&mut low_key)?;
+
+        file.seek(SeekFrom::Start(*offsets.last().unwrap() as u64))?;
+
+        let mut buf = [0u8; size_of::<usize>()];
+        file.read_exact(&mut buf)?;
+
+        let key_len = usize::from_le_bytes(buf);
+        let mut high_key = vec![0u8; key_len];
+        file.read_exact(&mut high_key)?;
+
+        Ok(SSTable {
+            file,
+            offsets,
+            low_key,
+            high_key,
+        })
+    }
+
+    pub fn key_in_range(&self, key: &[u8]) -> bool {
+        key >= &self.low_key && key <= &self.high_key
+    }
+
+    pub fn get(&mut self, key: &[u8]) -> io::Result<Option<SSTableEntry>> {
+        let mut a = 0;
+        let mut b = 0;
+        while a <= b {
+            let m = (a + b) / 2;
+            let offset = self.offsets[m];
+
+            self.file.seek(SeekFrom::Start(offset))?;
+
+            let mut buf = [0u8; size_of::<usize>()];
+            self.file.read_exact(&mut buf)?;
+
+            let key_len = usize::from_le_bytes(buf);
+            let mut table_key = vec![0u8; key_len];
+            self.file.read_exact(&mut table_key)?;
+
+            if key == &table_key {
+                let mut buf = [0u8; size_of::<u8>()];
+                self.file.read_exact(&mut buf)?;
+
+                let deleted = buf[0] == 1;
+
+                let mut val = None;
+                if !deleted {
+                    let mut buf = [0u8; size_of::<usize>()];
+                    self.file.read_exact(&mut buf)?;
+
+                    let val_len = usize::from_le_bytes(buf);
+                    let mut table_value = vec![0u8; val_len];
+                    self.file.read_exact(&mut table_value)?;
+
+                    val = Some(table_value)
+                }
+
+                let mut buf = [0u8; size_of::<u128>()];
+                self.file.read_exact(&mut buf)?;
+
+                let timestamp = u128::from_le_bytes(buf);
+
+                return Ok(Some(SSTableEntry {
+                    key: table_key,
+                    value: val,
+                    timestamp,
+                }));
+            } else if key > &table_key {
+                a = m + 1;
+            } else if key < &table_key {
+                b = m - 1;
+            }
+        }
+
+        Ok(None)
+    }
+}
+
+#[cfg(test)]
+mod tests {}