Merge pull request #111 from JakeRoggenbuck/page-save-state

Save state of everything

Author: JakeRoggenbuck

src/container.rs

@@ -1,7 +1,45 @@
 use super::page::PhysicalPage;
 use super::record::{Record, RecordAddress};
+use serde::{Deserialize, Serialize};
+use std::fs::File;
+use std::io::{BufReader, BufWriter, Write};
 use std::sync::{Arc, Mutex};
 
+#[derive(Clone, Default, Deserialize, Serialize, Debug)]
+pub struct BaseContainerMetadata {
+    // This takes the place of the actual pages in the disk version
+    // With this number, we are able to load all of the pages
+    num_pages: usize,
+
+    num_cols: i64,
+
+    rid_column: i64,
+    schema_encoding_column: i64,
+    indirection_column: i64,
+}
+
+impl BaseContainerMetadata {
+    pub fn load_state(&self) -> BaseContainer {
+        let mut base = BaseContainer::new(self.num_cols);
+
+        for i in 0..self.num_pages {
+            // Load the page
+            let p = PhysicalPage::load_state(i as i64);
+            // Put the page into an Arc Mutex
+            let m = Arc::new(Mutex::new(p));
+
+            // Add the physical page
+            base.physical_pages.push(m);
+        }
+
+        base.rid_column = self.rid_column;
+        base.schema_encoding_column = self.schema_encoding_column;
+        base.indirection_column = self.indirection_column;
+
+        return base;
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct BaseContainer {
     // pages
@@ -181,6 +219,71 @@ impl BaseContainer {
 
         values
     }
+
+    pub fn save_state(&self) {
+        let base_meta = self.get_metadata();
+        let hardcoded_filename = "./base_container.data";
+
+        let mut index = 0;
+        // The Rust compiler suggested that I clone here but it's definitely way better to not copy
+        // all of the data and just use a reference
+        for p in &self.physical_pages {
+            // Save the page
+            let m = p.lock().unwrap();
+            m.save_state(index);
+            index += 1;
+        }
+
+        let base_bytes: Vec<u8> = bincode::serialize(&base_meta).expect("Should serialize.");
+
+        let mut file = BufWriter::new(File::create(hardcoded_filename).expect("Should open file."));
+        file.write_all(&base_bytes).expect("Should serialize.");
+    }
+
+    pub fn get_metadata(&self) -> BaseContainerMetadata {
+        BaseContainerMetadata {
+            num_pages: self.physical_pages.len(),
+            num_cols: self.num_cols,
+            rid_column: self.rid_column,
+            schema_encoding_column: self.schema_encoding_column,
+            indirection_column: self.indirection_column,
+        }
+    }
+}
+
+#[derive(Clone, Default, Deserialize, Serialize, Debug)]
+pub struct TailContainerMetadata {
+    // This takes the place of the actual pages in the disk version
+    // With this number, we are able to load all of the pages
+    num_pages: usize,
+
+    num_cols: i64,
+
+    rid_column: i64,
+    schema_encoding_column: i64,
+    indirection_column: i64,
+}
+
+impl TailContainerMetadata {
+    pub fn load_state(&self) -> TailContainer {
+        let mut tail = TailContainer::new(self.num_cols);
+
+        for i in 0..self.num_pages {
+            // Load the page
+            let p = PhysicalPage::load_state(i as i64);
+            // Put the page into an Arc Mutex
+            let m = Arc::new(Mutex::new(p));
+
+            // Add the physical page
+            tail.physical_pages.push(m);
+        }
+
+        tail.rid_column = self.rid_column;
+        tail.schema_encoding_column = self.schema_encoding_column;
+        tail.indirection_column = self.indirection_column;
+
+        return tail;
+    }
 }
 
 #[derive(Clone, Default)]
@@ -357,6 +460,36 @@ impl TailContainer {
 
         values
     }
+
+    pub fn save_state(&self) {
+        let tail_meta = self.get_metadata();
+        let hardcoded_filename = "./tail_container.data";
+
+        let mut index = 0;
+        // The Rust compiler suggested that I clone here but it's definitely way better to not copy
+        // all of the data and just use a reference
+        for p in &self.physical_pages {
+            // Save the page
+            let m = p.lock().unwrap();
+            m.save_state(index);
+            index += 1;
+        }
+
+        let tail_bytes: Vec<u8> = bincode::serialize(&tail_meta).expect("Should serialize.");
+
+        let mut file = BufWriter::new(File::create(hardcoded_filename).expect("Should open file."));
+        file.write_all(&tail_bytes).expect("Should serialize.");
+    }
+
+    pub fn get_metadata(&self) -> TailContainerMetadata {
+        TailContainerMetadata {
+            num_pages: self.physical_pages.len(),
+            num_cols: self.num_cols,
+            rid_column: self.rid_column,
+            schema_encoding_column: self.schema_encoding_column,
+            indirection_column: self.indirection_column,
+        }
+    }
 }
 
 #[cfg(test)]

src/page.rs

@@ -1,5 +1,7 @@
 use pyo3::prelude::*;
 use serde::{Deserialize, Serialize};
+use std::fs::File;
+use std::io::{BufReader, BufWriter, Write};
 
 static MAX_SIZE_RECORD: i64 = i64::MAX;
 
@@ -36,6 +38,24 @@ impl PhysicalPage {
     pub fn read(&self, index: usize) -> Option<i64> {
         Some(self.data[index])
     }
+
+    pub fn save_state(&self, id: i64) {
+        let hardcoded_filename = format!("./{}-page.data", id);
+
+        let table_bytes: Vec<u8> = bincode::serialize(&self).expect("Should serialize.");
+
+        let mut file = BufWriter::new(File::create(hardcoded_filename).expect("Should open file."));
+        file.write_all(&table_bytes).expect("Should serialize.");
+    }
+
+    pub fn load_state(id: i64) -> PhysicalPage {
+        let hardcoded_filename = format!("./{}-page.data", id);
+
+        let file = BufReader::new(File::open(hardcoded_filename).expect("Should open file."));
+        let page: PhysicalPage = bincode::deserialize_from(file).expect("Should deserialize.");
+
+        return page;
+    }
 }
 
 #[cfg(test)]
@@ -50,6 +70,48 @@ mod tests {
         assert_eq!(phys_page.read(0).unwrap(), 10);
     }
 
+    #[test]
+    fn save_load_test() {
+        // Scope so that page_one and page_two get unallocated and leave scope
+        {
+            let mut page_one = PhysicalPage::new();
+            let mut page_two = PhysicalPage::new();
+
+            // Write to page_one
+            page_one.write(100);
+            page_one.write(200);
+            page_one.write(300);
+
+            // Write to page_two
+            page_two.write(111);
+            page_two.write(222);
+            page_two.write(333);
+
+            // Save page_one and page_two
+            page_one.save_state(1);
+            page_two.save_state(2);
+        }
+
+        // Load page_one and page_two
+        let mut page_one = PhysicalPage::load_state(1);
+        let mut page_two = PhysicalPage::load_state(2);
+
+        // Write to both pages once more
+        page_one.write(400);
+        page_two.write(444);
+
+        // Check that all the data is there
+        assert_eq!(page_one.read(0), Some(100));
+        assert_eq!(page_one.read(1), Some(200));
+        assert_eq!(page_one.read(2), Some(300));
+        assert_eq!(page_one.read(3), Some(400));
+
+        assert_eq!(page_two.read(0), Some(111));
+        assert_eq!(page_two.read(1), Some(222));
+        assert_eq!(page_two.read(2), Some(333));
+        assert_eq!(page_two.read(3), Some(444));
+    }
+
     #[test]
     fn many_writes_page_test() {
         let mut phys_page = PhysicalPage::new();

src/pagerange.rs

@@ -1,5 +1,16 @@
-use super::container::{BaseContainer, TailContainer};
+use super::container::{
+    BaseContainer, BaseContainerMetadata, TailContainer, TailContainerMetadata,
+};
 use super::record::Record;
+use serde::{Deserialize, Serialize};
+use std::fs::File;
+use std::io::{BufReader, BufWriter, Write};
+
+#[derive(Clone, Default, Deserialize, Serialize, Debug)]
+pub struct PageRangeMetadata {
+    pub base_container: BaseContainerMetadata,
+    pub tail_container: TailContainerMetadata,
+}
 
 #[derive(Clone, Default)]
 pub struct PageRange {
@@ -29,4 +40,39 @@ impl PageRange {
     pub fn read(&self, record: Record) -> Option<Vec<i64>> {
         Some(self.base_container.read_record(record))
     }
+
+    pub fn save_state(&self) {
+        // Save the state of the two containers
+        self.base_container.save_state();
+        self.tail_container.save_state();
+
+        let hardcoded_filename = "./pagerange.data";
+
+        let pr_meta = self.get_metadata();
+
+        let pr_bytes: Vec<u8> = bincode::serialize(&pr_meta).expect("Should serialize.");
+
+        let mut file = BufWriter::new(File::create(hardcoded_filename).expect("Should open file."));
+        file.write_all(&pr_bytes).expect("Should serialize.");
+    }
+
+    pub fn load_state() -> PageRange {
+        let hardcoded_filename = "./pagerange.data";
+
+        let file = BufReader::new(File::open(hardcoded_filename).expect("Should open file."));
+        let pr_meta: PageRangeMetadata =
+            bincode::deserialize_from(file).expect("Should deserialize.");
+
+        PageRange {
+            base_container: pr_meta.base_container.load_state(),
+            tail_container: pr_meta.tail_container.load_state(),
+        }
+    }
+
+    pub fn get_metadata(&self) -> PageRangeMetadata {
+        PageRangeMetadata {
+            base_container: self.base_container.get_metadata(),
+            tail_container: self.tail_container.get_metadata(),
+        }
+    }
 }

src/table.rs

@@ -1,5 +1,5 @@
 use super::index::RIndex;
-use super::pagerange::PageRange;
+use super::pagerange::{PageRange, PageRangeMetadata};
 use super::record::Record;
 use bincode;
 use pyo3::prelude::*;
@@ -14,6 +14,7 @@ pub struct RTableMetadata {
     pub primary_key_column: usize,
     pub num_records: i64,
     pub num_columns: usize,
+    pub page_range: PageRangeMetadata,
 }
 
 pub trait StatePersistence {
@@ -30,9 +31,7 @@ pub trait StatePersistence {
             num_columns: table_meta.num_columns,
             num_records: table_meta.num_records,
 
-            // TODO: Should we load these up too or create new ones?
-            // I think load them up to, so we need to do that as well
-            page_range: PageRange::new(table_meta.num_columns as i64),
+            page_range: PageRange::load_state(),
             page_directory: HashMap::new(),
             index: RIndex::new(),
         }
@@ -214,6 +213,9 @@ impl RTable {
     pub fn save_state(&self) {
         let hardcoded_filename = "./table.data";
 
+        // Save the state of the page range
+        self.page_range.save_state();
+
         let table_meta = self.get_metadata();
 
         let table_bytes: Vec<u8> = bincode::serialize(&table_meta).expect("Should serialize.");
@@ -228,6 +230,7 @@ impl RTable {
             primary_key_column: self.primary_key_column,
             num_columns: self.num_columns,
             num_records: self.num_records,
+            page_range: self.page_range.get_metadata(),
         }
     }