DB - Transactions with all statements

src/db/database.rs

@@ -2,8 +2,8 @@ use crate::db::table::core::{row::Row, table::Table};
 use crate::db::table::operations::{
     alter_table, create_table, delete, drop_table, insert, select, update,
 };
-use crate::db::transactions::rollback::rollback_transaction_entry;
-use crate::db::transactions::{TransactionEntry, TransactionLog};
+use crate::db::transactions::TransactionLog;
+use crate::db::transactions::{commit::commit_transaction, rollback::rollback_statement};
 use crate::interpreter::ast::SqlStatement;
 use std::collections::HashMap;
 
@@ -24,7 +24,7 @@ impl Database {
         let sql_statement_clone = sql_statement.clone();
         return match sql_statement {
             SqlStatement::CreateTable(statement) => {
-                create_table::create_table(self, statement)?;
+                create_table::create_table(self, statement, self.transaction.in_transaction())?;
                 self.transaction.append_entry(sql_statement_clone, vec![])?;
                 Ok(None)
             }
@@ -40,15 +40,17 @@ impl Database {
                 Ok(Some(result))
             }
             SqlStatement::UpdateStatement(statement) => {
+                let is_transaction = self.transaction.in_transaction();
                 let table = self.get_table_mut(&statement.table_name)?;
-                let rows_updated = update::update(table, statement)?;
+                let rows_updated = update::update(table, statement, is_transaction)?;
                 self.transaction
                     .append_entry(sql_statement_clone, rows_updated)?;
                 Ok(None)
             }
             SqlStatement::DeleteStatement(statement) => {
+                let is_transaction = self.transaction.in_transaction();
                 let table = self.get_table_mut(&statement.table_name)?;
-                let rows_deleted = delete::delete(table, statement)?;
+                let rows_deleted = delete::delete(table, statement, is_transaction)?;
                 self.transaction
                     .append_entry(sql_statement_clone, rows_deleted)?;
                 Ok(None)
@@ -68,37 +70,11 @@ impl Database {
                 Ok(None)
             }
             SqlStatement::Commit => {
-                let transaction_log = self.transaction.commit_transaction()?;
-                for transaction_entry in transaction_log.get_entries()?.iter() {
-                    match transaction_entry {
-                        TransactionEntry::Statement(statement) => {
-                            let table = self.get_table_mut(&statement.table_name)?;
-                            table.commit_transaction(&statement.affected_rows)?;
-                        }
-                        TransactionEntry::Savepoint(_) => {}
-                    }
-                }
-
+                commit_transaction(self)?;
                 Ok(None)
             }
-            SqlStatement::Rollback(_) => {
-                if let Some(transaction_log) = self.transaction.commit_transaction()?.entries {
-                    // We roll back in reverse order because of dependencies.
-                    for transaction_entry in transaction_log.iter().rev() {
-                        match transaction_entry {
-                            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 TABLE
-                                // - CREATE TABLE, DROP TABLE
-                                rollback_transaction_entry(self, &statement)?;
-                            }
-                            TransactionEntry::Savepoint(_) => {}
-                        }
-                    }
-                } else {
-                    return Err("No transaction is currently active".to_string());
-                }
+            SqlStatement::Rollback(statement) => {
+                rollback_statement(self, &statement)?;
                 Ok(None)
             }
             SqlStatement::Savepoint(_) => {

src/db/table/core/table.rs

@@ -9,7 +9,8 @@ use std::ops::{Index, IndexMut};
 pub struct Table {
     pub name: NameStack,
     pub columns: ColumnStack,
-    rows: Vec<RowStack>,
+    pub rows: Vec<RowStack>,
+    length: usize,
 }
 
 #[derive(Debug)]
@@ -37,6 +38,7 @@ impl Table {
             name: NameStack { stack: vec![name] },
             columns: ColumnStack::new(columns),
             rows: vec![],
+            length: 0,
         }
     }
 
@@ -56,19 +58,33 @@ impl Table {
     }
 
     pub fn get(&self, i: usize) -> Option<&Row> {
-        self.rows.get(i)?.stack.last()
+        if i < self.length {
+            self.rows.get(i)?.stack.last()
+        } else {
+            None
+        }
     }
 
     pub fn iter(&self) -> impl Iterator<Item = &Row> {
-        self.rows.iter().map(|s| s.stack.last().unwrap())
+        self.rows
+            .iter()
+            .take(self.length)
+            .map(|s| s.stack.last().unwrap())
     }
 
     pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Row> {
-        self.rows.iter_mut().map(|s| s.stack.last_mut().unwrap())
+        self.rows
+            .iter_mut()
+            .take(self.length)
+            .map(|s| s.stack.last_mut().unwrap())
     }
 
     pub fn len(&self) -> usize {
-        self.rows.len()
+        self.length
+    }
+
+    pub fn set_length(&mut self, length: usize) {
+        self.length = length;
     }
 
     pub fn swap(&mut self, a: usize, b: usize) {
@@ -79,17 +95,23 @@ impl Table {
     pub fn get_rows_clone(&self) -> Vec<Row> {
         self.rows
             .iter()
+            .take(self.length)
             .map(|s| s.stack.last().unwrap().clone())
             .collect()
     }
 
     pub fn get_rows(&self) -> Vec<&Row> {
-        self.rows.iter().map(|s| s.stack.last().unwrap()).collect()
+        self.rows
+            .iter()
+            .take(self.length)
+            .map(|s| s.stack.last().unwrap())
+            .collect()
     }
 
     pub fn get_rows_mut(&mut self) -> Vec<&mut Row> {
         self.rows
             .iter_mut()
+            .take(self.length)
             .map(|s| s.stack.last_mut().unwrap())
             .collect()
     }
@@ -104,14 +126,17 @@ impl Table {
     }
 
     pub fn set_rows(&mut self, rows: Vec<Row>) {
+        self.length = rows.len();
         self.rows = rows.into_iter().map(|r| RowStack::new(r)).collect();
     }
 
     pub fn push(&mut self, row: Row) {
+        self.length += 1;
         self.rows.push(RowStack::new(row));
     }
 
     pub fn pop(&mut self) -> Option<Row> {
+        self.length -= 1;
         self.rows.pop().and_then(|mut value| value.stack.pop())
     }
 
@@ -123,7 +148,16 @@ impl Table {
             } else {
                 return Err("Error committing transaction. Row stack is empty".to_string());
             }
-            // TODO: Add commit for column stack and name stack.
+        }
+        if self.columns.stack.len() > 1 {
+            let last_column_stack = self.columns.stack.pop().unwrap();
+            self.columns = ColumnStack::new(last_column_stack);
+        }
+        if self.name.stack.len() > 1 {
+            let last_name = self.name.stack.pop().unwrap();
+            self.name = NameStack {
+                stack: vec![last_name],
+            };
         }
         Ok(())
     }

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

@@ -5,6 +5,7 @@ use crate::interpreter::ast::{CreateTableStatement, ExistenceCheck};
 pub fn create_table(
     database: &mut Database,
     statement: CreateTableStatement,
+    is_transaction: bool,
 ) -> Result<(), String> {
     if database.has_table(&statement.table_name) {
         match statement.existence_check {
@@ -16,10 +17,18 @@ pub fn create_table(
             }
         }
     }
-    let table = Table::new(statement.table_name, statement.columns);
-    database
-        .tables
-        .insert(table.name()?.clone(), vec![Some(table)]);
+    let table = Table::new(statement.table_name.clone(), statement.columns);
+    if is_transaction && database.tables.contains_key(&statement.table_name) {
+        database
+            .tables
+            .get_mut(&statement.table_name)
+            .unwrap()
+            .push(Some(table));
+    } else {
+        database
+            .tables
+            .insert(table.name()?.clone(), vec![Some(table)]);
+    }
     Ok(())
 }
 
@@ -42,7 +51,7 @@ mod tests {
             }],
         };
         let mut database = Database::new();
-        assert!(create_table(&mut database, statement).is_ok());
+        assert!(create_table(&mut database, statement, false).is_ok());
         assert!(database.has_table("users"));
     }
 
@@ -58,7 +67,7 @@ mod tests {
             }],
         };
         let mut database = default_database();
-        let result = create_table(&mut database, statement);
+        let result = create_table(&mut database, statement, false);
         assert!(result.is_err());
         assert_eq!("Table users already exists", result.err().unwrap());
     }
@@ -75,7 +84,27 @@ mod tests {
             }],
         };
         let mut database = default_database();
-        let result = create_table(&mut database, statement);
+        let result = create_table(&mut database, statement, false);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn create_table_with_transaction_clause_works_correctly() {
+        let statement = CreateTableStatement {
+            table_name: "users".to_string(),
+            existence_check: None,
+            columns: vec![ColumnDefinition {
+                name: "id".to_string(),
+                data_type: DataType::Integer,
+                constraints: vec![],
+            }],
+        };
+        let mut database = Database::new();
+        let result = create_table(&mut database, statement, true);
         assert!(result.is_ok());
+        assert!(database.has_table("users"));
+        let table = database.tables.get("users").unwrap();
+        assert!(table.len() == 1);
+        assert!(table.first().unwrap().is_some());
     }
 }

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

@@ -4,18 +4,30 @@ use crate::db::table::core::table::Table;
 use crate::db::table::operations::helpers::common::get_row_indicies_matching_clauses;
 use crate::interpreter::ast::DeleteStatement;
 
-pub fn delete(table: &mut Table, statement: DeleteStatement) -> Result<Vec<usize>, String> {
-    let row_indicies_to_delete = get_row_indicies_matching_clauses(
+pub fn delete(
+    table: &mut Table,
+    statement: DeleteStatement,
+    is_transaction: bool,
+) -> Result<Vec<usize>, String> {
+    let mut row_indicies_to_delete = get_row_indicies_matching_clauses(
         table,
         &statement.where_clause,
         &statement.order_by_clause,
         &statement.limit_clause,
     )?;
-    swap_remove_bulk(table, &row_indicies_to_delete)?;
+    // We get omega saved here by the fact that we don't need to guarentee the order of the rows after rollbacks.
+    // This means we can swap the semi-deleted rows to the end of the table and then set the length of the table
+    // to the length of the table minus the number of semi-deleted rows. Then on rollback we can just extend the length of the table.
+    // to then include the deleted rows. if we commit, we pop off the end of the table until at the desired length.
+    swap_remove_bulk(table, &mut row_indicies_to_delete, is_transaction)?;
     Ok(row_indicies_to_delete)
 }
 
-fn swap_remove_bulk(table: &mut Table, row_indicies: &Vec<usize>) -> Result<(), String> {
+fn swap_remove_bulk(
+    table: &mut Table,
+    row_indicies: &mut Vec<usize>,
+    is_transaction: bool,
+) -> Result<(), String> {
     if table.len() == 0 {
         if row_indicies.len() != 0 {
             unreachable!();
@@ -25,7 +37,8 @@ fn swap_remove_bulk(table: &mut Table, row_indicies: &Vec<usize>) -> Result<(),
     let table_len = table.len() - 1;
     let mut row_indicies_set = row_indicies.iter().collect::<HashSet<&usize>>();
     let mut right_pointer = 0;
-    let mut iter = row_indicies.iter();
+    let mut iter = row_indicies.iter().rev(); // We recieve the indexes in ascending order,
+    // We reverse them to get rid of the furtherst indexes first.
 
     while let Some(to_swap) = iter.next() {
         if *to_swap == (table_len - right_pointer) {
@@ -37,8 +50,12 @@ fn swap_remove_bulk(table: &mut Table, row_indicies: &Vec<usize>) -> Result<(),
             right_pointer += 1;
         }
     }
-    for _ in 0..right_pointer {
-        table.pop();
+    if is_transaction {
+        table.set_length(table.len() - right_pointer);
+    } else {
+        for _ in 0..right_pointer {
+            table.pop();
+        }
     }
     Ok(())
 }
@@ -67,7 +84,7 @@ mod tests {
             order_by_clause: None,
             limit_clause: None,
         };
-        let result = delete(&mut table, statement);
+        let result = delete(&mut table, statement, false);
         assert!(result.is_ok());
         let expected = vec![
             Row(vec![
@@ -158,7 +175,7 @@ mod tests {
                 offset: Some(2),
             }),
         };
-        let result = delete(&mut table, statement);
+        let result = delete(&mut table, statement, false);
         assert!(result.is_ok());
         let expected = vec![
             Row(vec![
@@ -214,7 +231,7 @@ mod tests {
             order_by_clause: None,
             limit_clause: None,
         };
-        let result = delete(&mut table, statement);
+        let result = delete(&mut table, statement, false);
         assert!(result.is_ok());
         let row_indicies = result.unwrap();
         assert_eq!(vec![1, 2, 3], row_indicies);
@@ -236,7 +253,7 @@ mod tests {
             order_by_clause: None,
             limit_clause: None,
         };
-        let result = delete(&mut table, statement);
+        let result = delete(&mut table, statement, false);
         assert!(result.is_ok());
         let expected = vec![];
         assert_table_rows_eq_unordered(expected, table.get_rows_clone());
@@ -252,7 +269,7 @@ mod tests {
             order_by_clause: None,
             limit_clause: None,
         };
-        let result = delete(&mut table, statement);
+        let result = delete(&mut table, statement, false);
         assert!(result.is_ok());
     }
 
@@ -310,7 +327,7 @@ mod tests {
                 offset: Some(1),
             }),
         };
-        let result = delete(&mut table, statement);
+        let result = delete(&mut table, statement, false);
         assert!(result.is_ok());
         let deleted_indices = result.unwrap();
         assert_eq!(deleted_indices.len(), 2);
@@ -356,7 +373,7 @@ mod tests {
             order_by_clause: None,
             limit_clause: None,
         };
-        let result = delete(&mut table, statement);
+        let result = delete(&mut table, statement, false);
         assert!(result.is_ok());
         let deleted_indices = result.unwrap();
         assert_eq!(deleted_indices, vec![0]);