Merge pull request #109 from JakeRoggenbuck/save-db-state

Add state loader for database

Author: JakeRoggenbuck

src/database.rs

@@ -1,15 +1,28 @@
 use super::index::RIndex;
 use super::pagerange::PageRange;
-use super::table::RTable;
+use super::table::{RTable, RTableMetadata, StatePersistence};
 use pyo3::prelude::*;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::fs::File;
+use std::io::{BufReader, BufWriter, Write};
+use std::path::Path;
+
+#[derive(Serialize, Deserialize, Debug, Default)]
+pub struct RDatabaseMetadata {
+    tables: Vec<RTableMetadata>,
+    tables_hashmap: HashMap<String, usize>,
+    db_filepath: Option<String>,
+}
 
 #[pyclass]
 pub struct RDatabase {
     /// This is where we keep all of the tables
     tables: Vec<RTable>,
     // Map table names to index on the tables: Vec<RTable>
     tables_hashmap: HashMap<String, usize>,
+
+    db_filepath: Option<String>,
 }
 
 #[pymethods]
@@ -19,15 +32,67 @@ impl RDatabase {
         RDatabase {
             tables: vec![],
             tables_hashmap: HashMap::new(),
+            db_filepath: None,
         }
     }
 
-    fn open(&self, _path: String) {
-        // unreachable!("Not used in milestone 1");
+    fn open(&mut self, path: String) {
+        if self.db_filepath.is_none() {
+            self.db_filepath = Some(path.clone());
+        }
+
+        if let Some(p) = &self.db_filepath {
+            if !Path::new(&p).exists() {
+                // The database has not been closed yet
+                // Assuming the users makes sure to close the database before they want to open it
+                // again, we don't have to do anything else. We can just exit. The rest of the function
+                // only needs to load up the database if something exists to load up
+                return;
+            }
+        }
+
+        // Read the metadata of the database
+        let file = BufReader::new(File::open(path).expect("Should open file."));
+        let db_meta: RDatabaseMetadata =
+            bincode::deserialize_from(file).expect("Should deserialize.");
+
+        // Load each table metadata into this current databases' tables
+        let mut index = 0;
+        for table in &db_meta.tables {
+            self.tables.push(table.load_state());
+            self.tables_hashmap.insert(table.name.clone(), index);
+            index += 1;
+        }
     }
 
     fn close(&self) {
-        // unreachable!("Not used in milestone 1");
+        let mut database_meta = RDatabaseMetadata {
+            tables: Vec::<RTableMetadata>::new(),
+            tables_hashmap: self.tables_hashmap.clone(),
+            db_filepath: self.db_filepath.clone(),
+        };
+
+        for table in &self.tables {
+            // Get the metadata for each table
+            let tm: RTableMetadata = table.get_metadata();
+            // Push it to database_meta.tables
+            database_meta.tables.push(tm);
+
+            // Save the table to disk
+            table.save_state();
+        }
+
+        let table_bytes: Vec<u8> = bincode::serialize(&database_meta).expect("Should serialize.");
+
+        match &self.db_filepath {
+            Some(p) => {
+                let mut file = BufWriter::new(File::create(p).expect("Should open file."));
+                file.write_all(&table_bytes).expect("Should serialize.");
+            }
+            None => {
+                panic!("Could no write!") /* Quietly fail to write to disk */
+            }
+        }
     }
 
     pub fn create_table(

src/table.rs

@@ -9,13 +9,39 @@ use std::fs::File;
 use std::io::{BufReader, BufWriter, Write};
 
 #[derive(Serialize, Deserialize, Debug)]
-struct RTableMetadata {
-    name: String,
-    primary_key_column: usize,
-    num_records: i64,
-    num_columns: usize,
+pub struct RTableMetadata {
+    pub name: String,
+    pub primary_key_column: usize,
+    pub num_records: i64,
+    pub num_columns: usize,
+}
+
+pub trait StatePersistence {
+    fn load_state(&self) -> RTable {
+        let hardcoded_filename = "./table.data";
+
+        let file = BufReader::new(File::open(hardcoded_filename).expect("Should open file."));
+        let table_meta: RTableMetadata =
+            bincode::deserialize_from(file).expect("Should deserialize.");
+
+        RTable {
+            name: table_meta.name.clone(),
+            primary_key_column: table_meta.primary_key_column,
+            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_directory: HashMap::new(),
+            index: RIndex::new(),
+        }
+    }
 }
 
+impl StatePersistence for RTableMetadata {}
+impl StatePersistence for RTable {}
+
 #[derive(Clone, Default)]
 #[pyclass]
 pub struct RTable {
@@ -188,37 +214,20 @@ impl RTable {
     pub fn save_state(&self) {
         let hardcoded_filename = "./table.data";
 
-        let table_meta = RTableMetadata {
-            name: self.name.clone(),
-            num_columns: self.num_columns,
-            num_records: self.num_records,
-            primary_key_column: self.primary_key_column,
-        };
+        let table_meta = self.get_metadata();
 
         let table_bytes: Vec<u8> = bincode::serialize(&table_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.");
     }
 
-    pub fn load_state(&self) -> RTable {
-        let hardcoded_filename = "./table.data";
-
-        let file = BufReader::new(File::open(hardcoded_filename).expect("Should open file."));
-        let table_meta: RTableMetadata =
-            bincode::deserialize_from(file).expect("Should deserialize.");
-
-        RTable {
-            name: table_meta.name.clone(),
-            primary_key_column: table_meta.primary_key_column,
-            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_directory: HashMap::new(),
-            index: RIndex::new(),
+    pub fn get_metadata(&self) -> RTableMetadata {
+        RTableMetadata {
+            name: self.name.clone(),
+            primary_key_column: self.primary_key_column,
+            num_columns: self.num_columns,
+            num_records: self.num_records,
         }
     }