Add test

sqlite_core/src/input_buffer.rs

@@ -0,0 +1,92 @@
+use crate::interaction::Interaction;
+use crate::statement::{ExecuteResult, StatementResultType};
+use crate::table::Table;
+use crate::{interaction, statement};
+use std::ops::Deref;
+use std::sync::Arc;
+
+pub struct InputBuffer {
+    buffer: Option<String>,
+    table: Table,
+    interaction: Arc<dyn interaction::Interaction>,
+}
+
+impl InputBuffer {
+    pub fn new(interaction: Arc<dyn Interaction>) -> Self {
+        return Self {
+            buffer: None,
+            table: Table::new(),
+            interaction,
+        };
+    }
+
+    pub fn print_prompt(&mut self) -> &mut Self {
+        self.interaction.output(String::from("db > "));
+        self
+    }
+
+    pub fn read_input(&mut self) -> Result<&mut Self, String> {
+        self.buffer = Some(String::new());
+        match &mut self.buffer {
+            Some(input_buffer) => {
+                if let Ok(input) = self.interaction.input() {
+                    *input_buffer = input.to_string();
+                    Ok(self)
+                } else {
+                    Err(String::from("could not handle input"))
+                }
+            }
+            _ => Err(String::from("Could not initialize buffer")),
+        }
+    }
+
+    pub fn parse(&mut self, on_exit: fn() -> ()) {
+        match &self.buffer {
+            Some(command) => {
+                if command.starts_with(".") {
+                    Self::handle_meta_statement(command, on_exit);
+                } else {
+                    match Self::prepare_statement(&command.replace("\n", "")) {
+                        Ok(statement) => {
+                            let execution_result = statement.execute(&mut self.table);
+                            match execution_result {
+                                ExecuteResult::Success {
+                                    statement_result_type: StatementResultType::Insert,
+                                } => self
+                                    .interaction
+                                    .deref()
+                                    .output(String::from("insert success\n")),
+                                ExecuteResult::Success {
+                                    statement_result_type: StatementResultType::Select { rows },
+                                } => {
+                                    for row in rows {
+                                        self.interaction.output(row.print())
+                                    }
+                                    self.interaction.output(String::from("select success\n"))
+                                }
+                                _ => self.interaction.output(String::from("failure\n")),
+                            }
+                        }
+                        Err(e) => {
+                            self.interaction.output(format!("{}\n", e));
+                        }
+                    }
+                }
+            }
+            None => {}
+        }
+    }
+
+    fn prepare_statement(command: &String) -> Result<statement::Statement, String> {
+        return statement::Statement::parse_statement(command);
+    }
+
+    fn handle_meta_statement(command: &String, on_exit: fn()) {
+        match command.replace("\n", "").trim() {
+            ".exit" => on_exit(),
+            cmd => {
+                println!("Could not handle command: {cmd}")
+            }
+        }
+    }
+}