DB - Reformat String issues with Errors

src/db/database.rs

@@ -72,7 +72,7 @@ impl Database {
                 for transaction_entry in transaction_log.get_entries()?.iter() {
                     match transaction_entry {
                         TransactionEntry::Statement(statement) => {
-                            let table = self.get_table_mut(statement.table_name.as_str())?;
+                            let table = self.get_table_mut(&statement.table_name)?;
                             table.commit_transaction(&statement.affected_rows)?;
                         }
                         TransactionEntry::Savepoint(_) => {}
@@ -89,7 +89,8 @@ impl Database {
                             TransactionEntry::Statement(statement) => {
                                 // TODO: Some matching needs to be here for table based operations.
                                 // CURRENTLY SUPPORTED STATEMENTS ARE:
-                                // - ALTER TABLE RENAME COLUMN, ALTER TABLE ADD COLUMN, ALTER TABLE DROP COLUMN
+                                // - ALTER TABLE RENAME COLUMN, ALTER TABLE ADD COLUMN, ALTER TABLE DROP COLUMN, ALTER TABLE RENAME TABLE
+                                // - CREATE TABLE, DROP TABLE
                                 rollback_transaction_entry(self, &statement)?;
                             }
                             TransactionEntry::Savepoint(_) => {}

src/db/table/core/column.rs

@@ -93,12 +93,14 @@ impl ColumnStack {
     }
 
     fn peek(&self) -> Result<&Vec<ColumnDefinition>, String> {
-        self.stack.last().ok_or("Column stack is empty".to_string())
+        self.stack
+            .last()
+            .ok_or_else(|| "Column stack is empty".to_string())
     }
 
     fn peek_mut(&mut self) -> Result<&mut Vec<ColumnDefinition>, String> {
         self.stack
             .last_mut()
-            .ok_or("Column stack is empty".to_string())
+            .ok_or_else(|| "Column stack is empty".to_string())
     }
 }

src/db/table/core/table.rs

@@ -44,7 +44,7 @@ impl Table {
         self.name
             .stack
             .last()
-            .ok_or("Error fetching table name.".to_string())
+            .ok_or_else(|| "Error fetching table name.".to_string())
     }
 
     pub fn change_name(&mut self, new_name: String, is_transaction: bool) {
@@ -71,10 +71,11 @@ impl Table {
         self.rows.len()
     }
 
-    pub fn swap(&mut self, a: usize, b: usize) -> () {
+    pub fn swap(&mut self, a: usize, b: usize) {
         self.rows.swap(a, b);
     }
 
+    #[cfg(test)]
     pub fn get_rows_clone(&self) -> Vec<Row> {
         self.rows
             .iter()
@@ -93,8 +94,8 @@ impl Table {
             .collect()
     }
 
-    pub fn get_row_stacks_mut(&mut self) -> Vec<&mut RowStack> {
-        self.rows.iter_mut().collect()
+    pub fn get_row_stacks_mut(&mut self) -> &mut Vec<RowStack> {
+        &mut self.rows
     }
 
     #[cfg(test)]
@@ -122,6 +123,7 @@ impl Table {
             } else {
                 return Err("Error committing transaction. Row stack is empty".to_string());
             }
+            // TODO: Add commit for column stack and name stack.
         }
         Ok(())
     }
@@ -179,7 +181,7 @@ impl Table {
             .columns
             .stack
             .last()
-            .ok_or("Column stack is empty".to_string())?
+            .ok_or_else(|| "Column stack is empty".to_string())?
             .iter()
             .collect())
     }
@@ -189,7 +191,7 @@ impl Table {
             .columns
             .stack
             .last_mut()
-            .ok_or("Column stack is empty".to_string())?
+            .ok_or_else(|| "Column stack is empty".to_string())?
             .iter_mut()
             .collect())
     }

src/db/table/operations/alter_table/mod.rs

@@ -9,9 +9,9 @@ pub fn alter_table(
 ) -> Result<(), String> {
     return match statement.action {
         AlterTableAction::RenameTable { new_table_name } => {
-            let mut table = database.pop_table_change(statement.table_name.as_str())?;
+            let mut table = database.pop_table_change(&statement.table_name)?;
             table.change_name(new_table_name.clone(), is_transaction);
-            database.push_table_change(new_table_name.as_str(), table);
+            database.push_table_change(&new_table_name, table);
             Ok(())
         }
         AlterTableAction::RenameColumn {

src/db/table/operations/select/mod.rs

@@ -80,10 +80,12 @@ pub fn select_statement_stack(
                 result_indices.push(
                     column_names
                         .as_ref()
-                        .ok_or("No column names found".to_string())?
+                        .ok_or_else(|| "No column names found".to_string())?
                         .iter()
                         .position(|column_name| column_name == order_by_column_name)
-                        .ok_or("Ordering column name not found in selected columns".to_string())?,
+                        .ok_or_else(|| {
+                            "Ordering column name not found in selected columns".to_string()
+                        })?,
                 );
             }
 

src/db/table/operations/select/set_operator_evaluator.rs

@@ -26,7 +26,7 @@ impl SetOperatorEvaluator {
     fn pop(&mut self) -> Result<Vec<Row>, String> {
         self.stack
             .pop()
-            .ok_or("Error processing SELECT statement. Stack is empty".to_string())
+            .ok_or_else(|| "Error processing SELECT statement. Stack is empty".to_string())
     }
 
     pub fn union(&mut self) -> Result<(), String> {

src/db/transactions/rollback.rs

@@ -9,34 +9,34 @@ pub fn rollback_transaction_entry(
     match &statement.statement {
         SqlStatement::AlterTable(alter_table) => match alter_table.action {
             AlterTableAction::RenameColumn { .. } => {
-                let table = database.get_table_mut(statement.table_name.as_str())?;
+                let table = database.get_table_mut(&statement.table_name)?;
                 table.rollback_columns();
             }
             AlterTableAction::AddColumn { .. } => {
-                let table = database.get_table_mut(statement.table_name.as_str())?;
+                let table = database.get_table_mut(&statement.table_name)?;
                 table.rollback_columns();
                 table.rollback_all_rows();
             }
             AlterTableAction::DropColumn { .. } => {
-                let table = database.get_table_mut(statement.table_name.as_str())?;
+                let table = database.get_table_mut(&statement.table_name)?;
                 table.rollback_columns();
                 table.rollback_all_rows();
             }
             AlterTableAction::RenameTable { ref new_table_name } => {
                 // It is now under the new name
-                let mut table = database.pop_table_change(new_table_name.as_str())?;
+                let mut table = database.pop_table_change(&new_table_name)?;
                 table.rollback_name();
-                database.push_table_change(statement.table_name.as_str(), table);
+                database.push_table_change(&statement.table_name, table);
             }
         },
         SqlStatement::Select(_) => {} // These should be kept in the log but obv do nothing.
         SqlStatement::CreateTable(_) => {
-            database.tables.remove(statement.table_name.as_str());
+            database.tables.remove(&statement.table_name);
         }
         SqlStatement::DropTable(statement) => {
             database
                 .tables
-                .get_mut(statement.table_name.as_str())
+                .get_mut(&statement.table_name)
                 .unwrap()
                 .pop();
         }