Merge pull request #117 from JakeRoggenbuck/repopulate-page-dir

Full data save on disk

Author: JakeRoggenbuck

src/record.rs

@@ -1,5 +1,6 @@
 use super::page::PhysicalPage;
 use pyo3::prelude::*;
+use serde::{Deserialize, Serialize};
 use std::sync::{Arc, Mutex};
 
 #[derive(Debug, Clone)]
@@ -8,6 +9,61 @@ pub struct RecordAddress {
     pub offset: i64,
 }
 
+impl RecordAddress {
+    pub fn get_metadata(&self) -> RecordAddressMetadata {
+        RecordAddressMetadata {
+            // TODO: Get the index of each page
+            page_index: -1,
+            offset: self.offset,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RecordAddressMetadata {
+    // What page (basically the column index)
+    pub page_index: i64,
+
+    pub offset: i64,
+}
+
+impl RecordAddressMetadata {
+    pub fn load_state(&self) -> RecordAddress {
+        // TODO: Get the actual physical page by reference
+        let phys_page: PhysicalPage = PhysicalPage::new();
+
+        RecordAddress {
+            page: Arc::new(Mutex::new(phys_page)),
+            offset: self.offset,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RecordMetadata {
+    pub rid: i64,
+
+    pub addresses: Vec<RecordAddressMetadata>,
+}
+
+impl RecordMetadata {
+    pub fn load_state(&self) -> Record {
+        let mut rec_addrs = Vec::new();
+
+        // Create the RecordAddresses from the metadata
+        // This eventually gets propagated through load_state
+        // calls all the way to PageDirectory
+        for rec_addr in &self.addresses {
+            rec_addrs.push(rec_addr.load_state());
+        }
+
+        Record {
+            rid: self.rid,
+            addresses: Arc::new(Mutex::new(rec_addrs)),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 #[pyclass]
 pub struct Record {
@@ -19,6 +75,25 @@ pub struct Record {
     pub addresses: Arc<Mutex<Vec<RecordAddress>>>,
 }
 
+impl Record {
+    pub fn get_metadata(&self) -> RecordMetadata {
+        let mut rm = RecordMetadata {
+            rid: self.rid,
+            addresses: Vec::new(),
+        };
+
+        let m = self.addresses.lock().unwrap();
+        let addrs = m.iter();
+
+        for addr in addrs {
+            // Get the metadata for each RecordAddress
+            rm.addresses.push(addr.get_metadata());
+        }
+
+        return rm;
+    }
+}
+
 #[pymethods]
 impl Record {
     fn __str__(&self) -> String {

src/table.rs

@@ -1,13 +1,18 @@
 use super::index::RIndex;
 use super::pagerange::{PageRange, PageRangeMetadata};
-use super::record::Record;
+use super::record::{Record, RecordMetadata};
 use bincode;
 use pyo3::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::{BufReader, BufWriter, Write};
 
+#[derive(Default, Clone, Serialize, Deserialize)]
+pub struct PageDirectoryMetadata {
+    pub directory: HashMap<i64, RecordMetadata>,
+}
+
 #[derive(Default, Clone)]
 pub struct PageDirectory {
     pub directory: HashMap<i64, Record>,
@@ -21,10 +26,47 @@ impl PageDirectory {
     }
 
     fn load_state() -> PageDirectory {
-        PageDirectory::default()
+        let hardcoded_filename = "./redoxdata/page_directory.data";
+
+        let file = BufReader::new(File::open(hardcoded_filename).expect("Should open file."));
+        let page_meta: PageDirectoryMetadata =
+            bincode::deserialize_from(file).expect("Should deserialize.");
+
+        let mut pd: PageDirectory = PageDirectory {
+            directory: HashMap::new(),
+        };
+
+        // TODO: We need to somehow load all of the physical pages, wrap them 
+        // in an Arc Mutex, and assign those references to the record addresses
+        // that need them
+        //
+        // We could store the id for where the the physical page it stored on disk
+        // in the physical, and then we can load all of them up here, assuming we
+        // have something storing the max page index
+
+        for (rid, record_meta) in page_meta.directory {
+            pd.directory.insert(rid, record_meta.load_state());
+        }
+
+        return pd;
     }
 
     fn save_state(&self) {
+        let hardcoded_filename = "./redoxdata/page_directory.data";
+
+        let mut pd_meta = PageDirectoryMetadata {
+            directory: HashMap::new(),
+        };
+
+        for (rid, record) in &self.directory {
+            let r: RecordMetadata = record.get_metadata();
+            pd_meta.directory.insert(*rid, r);
+        }
+
+        let table_bytes: Vec<u8> = bincode::serialize(&pd_meta).expect("Should serialize.");
+
+        let mut file = BufWriter::new(File::create(hardcoded_filename).expect("Should open file."));
+        file.write_all(&table_bytes).expect("Should serialize.");
     }
 }
 
@@ -236,6 +278,8 @@ impl RTable {
         // Save the state of the page range
         self.page_range.save_state();
 
+        self.page_directory.save_state();
+
         let table_meta = self.get_metadata();
 
         let table_bytes: Vec<u8> = bincode::serialize(&table_meta).expect("Should serialize.");