From 997162c555b31c1ae55559011272a78ddf0e1597 Mon Sep 17 00:00:00 2001 From: Yuriy Dupyn <2153100+omedusyo@users.noreply.github.com> Date: Mon, 5 Feb 2024 21:46:18 +0100 Subject: [PATCH] Prepare for delete --- minisql/src/interpreter2.rs | 88 ++++++++++++++++++++++++---- minisql/src/response_writer.rs | 2 +- storage_engine/src/cursor.rs | 10 ++++ storage_engine/src/segments/entry.rs | 4 -- 4 files changed, 86 insertions(+), 18 deletions(-) diff --git a/minisql/src/interpreter2.rs b/minisql/src/interpreter2.rs index 7004b1f..9ca3de1 100644 --- a/minisql/src/interpreter2.rs +++ b/minisql/src/interpreter2.rs @@ -14,9 +14,10 @@ use std::rc::Rc; use tokio::fs; use storage_engine::store::Store; +use storage_engine::segments::entry::Entry; use storage_engine::cursor::{ReadCursor, WriteCursor}; use storage_engine::cursor_capabilities::traversal::CursorCanTraverse; -use storage_engine::cursor_capabilities::index_access::CursorCanReadIndex; +use storage_engine::cursor_capabilities::index_access::{CursorCanReadIndex, CursorCanWriteToIndex}; // ==============Interpreter================ #[derive(Debug)] @@ -140,6 +141,20 @@ impl State { Ok(count) } + + async fn delete_all_rows(table_name: String, mut cursor: WriteCursor<'_, Value>, response_writer: &mut Writer) -> DbResult { + // cursor. + let count = cursor.delete_all_entries(true) + .await.map_err(|e| RuntimeError::StorageEngineError(table_name, e))?; + Ok(count) + } + + async fn delete_all_eq(table_name: String, mut cursor: WriteCursor<'_, Value>, response_writer: &mut Writer, eq_column: Column, value: Value) -> DbResult { + let count = + cursor.delete_entries_where_eq(eq_column as storage_engine::store::Column, &value, true) + .await.map_err(|e| RuntimeError::StorageEngineError(table_name, e))?; + Ok(count) + } } impl StateHandler { @@ -176,14 +191,26 @@ impl StateHandler { } Insert(table_position, values) => { let state = self.state.read().await; - todo!() + let mut table = state.table_at_mut(table_position).await; + let mut cursor = table.write().await?; + + let entry = Entry::new(values); + cursor.insert_entry(entry).await.map_err(|e| RuntimeError::StorageEngineError(table.table_name().to_string(), e))?; + + response_writer.write_command_complete(CompleteStatus::Insert { oid: 0, rows: 1 }).await.map_err(|e| RuntimeError::AnyhowError(e)) } Delete(table_position, maybe_condition) => { let state = self.state.read().await; let mut table = state.table_at_mut(table_position).await; - let cursor = table.write().await?; + let table_name = table.table_name().clone(); + let mut cursor = table.write().await?; - todo!() + let count = match maybe_condition { + None => State::delete_all_rows(table_name, cursor, response_writer).await?, + Some(Condition::Eq(eq_column, value)) => State::delete_all_eq(table_name, cursor, response_writer, eq_column, value).await? + }; + + response_writer.write_command_complete(CompleteStatus::Delete(count)).await.map_err(|e| RuntimeError::AnyhowError(e)) } CreateTable(table_schema) => { let mut state = self.state.write().await; @@ -247,16 +274,51 @@ mod tests { .interpret(&mut response_writer, Operation::CreateTable(users_schema.clone())).await .unwrap(); - let users_position: TablePosition = 0; - state - .interpret(&mut response_writer, Operation::Select( - users_position, - users_schema.all_selection(), - None, - )).await - .unwrap(); + { + println!("==EMPTY SELECT==="); + let users_position: TablePosition = 0; + state + .interpret(&mut response_writer, Operation::Select( + users_position, + users_schema.all_selection(), + None, + )).await + .unwrap(); + } - // assert!(false); + { + let users = 0; + let (id, name, age) = ( + Value::Uuid(0), + Value::String("Plato".to_string()), + Value::Int(64), + ); + + println!("About to insert!"); + + state + .interpret(&mut response_writer, Operation::Insert( + users, + vec![id.clone(), name.clone(), age.clone()], + )).await + .unwrap(); + } + { + println!("==SELECT==="); + let users_position: TablePosition = 0; + state + .interpret(&mut response_writer, Operation::Select( + users_position, + users_schema.all_selection(), + None, + )).await + .unwrap(); + } + + + + + assert!(false); // assert!(state.tables.len() == 1); // let table = &state.tables[0]; diff --git a/minisql/src/response_writer.rs b/minisql/src/response_writer.rs index 30158c5..240a2f8 100644 --- a/minisql/src/response_writer.rs +++ b/minisql/src/response_writer.rs @@ -65,7 +65,7 @@ impl ResponseWriter for ResponseWriterStub async fn write_table_row(&mut self, row: &RestrictedRow) -> anyhow::Result<()> { for (_, value) in row.iter() { - print!("{:?}", value) + print!("{:?}, ", value) } println!(); diff --git a/storage_engine/src/cursor.rs b/storage_engine/src/cursor.rs index 2bc61c1..43b0ca5 100644 --- a/storage_engine/src/cursor.rs +++ b/storage_engine/src/cursor.rs @@ -244,6 +244,16 @@ impl <'cursor, T> WriteCursor<'cursor, T> Ok(count) } + pub async fn delete_all_entries(&mut self, enable_garbage_collector: bool) -> Result + where T: Encode + Decode + Ord + Send + Sync + Clone + { + let count = todo!(); + if enable_garbage_collector { + self.attempt_garbage_collection_if_necessary().await?; + } + Ok(count) + } + pub async fn delete_entries_where_eq(&mut self, column: Column, value: &T, enable_garbage_collector: bool) -> Result where T: Encode + Decode + Ord + Send + Sync + Clone { diff --git a/storage_engine/src/segments/entry.rs b/storage_engine/src/segments/entry.rs index 64f6381..a2f8bc8 100644 --- a/storage_engine/src/segments/entry.rs +++ b/storage_engine/src/segments/entry.rs @@ -23,10 +23,6 @@ impl Entry { Self { header: EntryHeader { is_deleted: false }, data } } - pub fn new_deleted(data: Vec) -> Self { - Self { header: EntryHeader { is_deleted: true}, data } - } - // FORMAT: [EntryHeaderWithDataSize, ..sequence of data] pub fn encode(&self) -> Result> where T: Encode