Add table names to hash and open files

Allow non-existing files to be "opened" and later written to so that
they can be opened for real later after we write data

Author: JakeRoggenbuck

src/database.rs

@@ -6,11 +6,13 @@ 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]
@@ -19,6 +21,8 @@ pub struct RDatabase {
     tables: Vec<RTable>,
     // Map table names to index on the tables: Vec<RTable>
     tables_hashmap: HashMap<String, usize>,
+
+    db_filepath: Option<String>,
 }
 
 #[pymethods]
@@ -28,39 +32,67 @@ impl RDatabase {
         RDatabase {
             tables: vec![],
             tables_hashmap: HashMap::new(),
+            db_filepath: None,
         }
     }
 
-    fn open(&mut self, _path: String) {
-        // TODO: Read the metadata of the database
-        let db_meta = RDatabaseMetadata::default();
+    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) {
-        // TODO: Save the metadata of the database
-
-        let hardcoded_filename = "./database.data";
-
-        let database_meta = RDatabaseMetadata {
+        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 {
-            // TODO: Get the metadata for each table
-            // TODO: Push it to database_meta.tables
-            table.save_state()
+            // 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.");
 
-        let mut file = BufWriter::new(File::create(hardcoded_filename).expect("Should open file."));
-        file.write_all(&table_bytes).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

@@ -214,19 +214,23 @@ 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 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,
+        }
+    }
+
     fn _merge() {
         unreachable!("Not used in milestone 1")
     }