Prepare for delete

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<Writer: ResponseWriter>(table_name: String, mut cursor: WriteCursor<'_, Value>, response_writer: &mut Writer) -> DbResult<usize> {
+        // cursor.
+        let count = cursor.delete_all_entries(true)
+            .await.map_err(|e| RuntimeError::StorageEngineError(table_name, e))?;
+        Ok(count)
+    }
+
+    async fn delete_all_eq<Writer: ResponseWriter>(table_name: String, mut cursor: WriteCursor<'_, Value>, response_writer: &mut Writer, eq_column: Column, value: Value) -> DbResult<usize> {
+        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
+            println!("==EMPTY SELECT===");
-            .interpret(&mut response_writer, Operation::Select(
+            let users_position: TablePosition = 0;
-                users_position,
+            state
-                users_schema.all_selection(),
+                .interpret(&mut response_writer, Operation::Select(
-                None,
+                    users_position,
-            )).await
+                    users_schema.all_selection(),
-            .unwrap();
+                    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];

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!();
 

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<usize> 
+        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<usize> 
         where T: Encode + Decode + Ord + Send + Sync + Clone
     {

storage_engine/src/segments/entry.rs

@@ -23,10 +23,6 @@ impl <T>Entry<T> {
         Self { header: EntryHeader { is_deleted: false }, data }
     }
 
-    pub fn new_deleted(data: Vec<T>) -> Self {
-        Self { header: EntryHeader { is_deleted: true}, data }
-    }
-
     // FORMAT: [EntryHeaderWithDataSize, ..sequence of data]
     pub fn encode(&self) -> Result<Vec<u8>> 
         where T: Encode