From 002ac4c6485730eb9dfe2da9978be23e1a382cd4 Mon Sep 17 00:00:00 2001
From: Yuriy Dupyn <2153100+omedusyo@users.noreply.github.com>
Date: Mon, 5 Feb 2024 19:37:10 +0100
Subject: [PATCH] Selet responses + table creation

---
 minisql/src/interpreter2.rs | 48 +++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/minisql/src/interpreter2.rs b/minisql/src/interpreter2.rs
index b96a071..2ef8765 100644
--- a/minisql/src/interpreter2.rs
+++ b/minisql/src/interpreter2.rs
@@ -105,28 +105,31 @@ impl State {
         self.tables.push(table);
     }
 
-    async fn select_all_rows<Writer: ResponseWriter>(table: &Table, mut cursor: ReadCursor<'_, Value>, response_writer: &mut Writer, column_selection: ColumnSelection) -> DbResult<()> {
+    async fn select_all_rows<Writer: ResponseWriter>(table: &Table, mut cursor: ReadCursor<'_, Value>, response_writer: &mut Writer, column_selection: ColumnSelection) -> DbResult<usize> {
+        let mut count = 0;
         while let Some(entry) = cursor.next_alive().await.map_err(|e| RuntimeError::StorageEngineError(table.table_name().to_string(), e))? {
+            count += 1;
             let row: Row = From::from(entry);
             let restricted_row = row.restrict_columns(&column_selection);
             response_writer.write_table_row(&restricted_row).await.map_err(|e| RuntimeError::AnyhowError(e))?;
         }
-        // TODO: You need to write COmmand complete
-        Ok(())
+
+        Ok(count)
     }
 
-    async fn select_eq<Writer: ResponseWriter>(table: &Table, mut cursor: ReadCursor<'_, Value>, response_writer: &mut Writer, column_selection: ColumnSelection, column: Column, value: Value) -> DbResult<()> {
+    async fn select_eq<Writer: ResponseWriter>(table: &Table, mut cursor: ReadCursor<'_, Value>, response_writer: &mut Writer, column_selection: ColumnSelection, column: Column, value: Value) -> DbResult<usize> {
         let entries = cursor.select_entries_where_eq(column as storage_engine::store::Column, &value).await.map_err(|e| RuntimeError::StorageEngineError(table.table_name().to_string(), e))?;
+        let count = entries.len();
         for entry in entries {
             let row: Row = From::from(entry);
             let restricted_row = row.restrict_columns(&column_selection);
             response_writer.write_table_row(&restricted_row).await.map_err(|e| RuntimeError::AnyhowError(e))?;
         }
-        // TODO: You need to write COmmand complete
-        Ok(())
+
+        Ok(count)
     }
 
-    pub async fn interpret<Writer: ResponseWriter>(&mut self, response_writer: &mut Writer, operation: Operation) -> DbResult<()> {
+    pub async fn interpret<Writer: ResponseWriter>(&mut self, db_path: &Path, response_writer: &mut Writer, operation: Operation) -> DbResult<()> {
         use Operation::*;
 
         match operation {
@@ -135,15 +138,11 @@ impl State {
                 let cursor = table.read().await?;
 
                 response_writer.write_table_header(&table.schema, &column_selection).await.map_err(|e| RuntimeError::AnyhowError(e))?;
-                match maybe_condition {
-                    None => {
-                        Self::select_all_rows(&table, cursor, response_writer, column_selection).await
-                    }
-
-                    Some(Condition::Eq(eq_column, value)) => {
-                        Self::select_eq(&table, cursor, response_writer, column_selection, eq_column, value).await
-                    }
-                }
+                let count = match maybe_condition {
+                    None => Self::select_all_rows(&table, cursor, response_writer, column_selection).await?,
+                    Some(Condition::Eq(eq_column, value)) => Self::select_eq(&table, cursor, response_writer, column_selection, eq_column, value).await?
+                };
+                response_writer.write_command_complete(CompleteStatus::Select(count)).await.map_err(|e| RuntimeError::AnyhowError(e))
             }
             Insert(table_position, values) => {
                 let table: &mut Table = self.table_at_mut(table_position);
@@ -156,9 +155,6 @@ impl State {
                 todo!()
             }
             CreateTable(table_schema) => {
-                // TODO: This needs to be given from a config
-                let db_path = "test_db";
-
                 let table = Table::new(table_schema, Path::new(db_path)).await?;
                 self.attach_table(table).await;
                 response_writer.write_command_complete(CompleteStatus::CreateTable).await.map_err(|e| RuntimeError::AnyhowError(e))
@@ -181,6 +177,16 @@ mod tests {
     use crate::type_system::{DbType, IndexableValue, Value};
     use std::collections::HashSet;
 
+    impl Drop for State {
+        fn drop(&mut self) {
+            println!("CLEANING UP INTERPRETER STATE");
+            // TODO
+            // let table_folder = self.header.table_folder.clone();
+            // Seems no one has figured out how to do AsyncDrop yet.
+            // std::fs::remove_dir_all(table_folder).unwrap();
+        }
+    }
+
     fn users_schema() -> TableSchema {
         TableSchema::new(
             "users".to_string(),
@@ -190,8 +196,8 @@ mod tests {
         )
     }
 
-    #[test]
-    fn test_table_creation() {
+    #[tokio::test]
+    async fn test_table_creation() {
         let mut state = State::new();
         let users_schema = users_schema();
         let users = users_schema.table_name().clone();