Fletcher/feat db create table

src/cli/ast/common.rs

@@ -1,4 +1,5 @@
-use crate::cli::{ast::parser::Parser, table::Value, tokenizer::token::TokenTypes};
+use crate::cli::{ast::parser::Parser, tokenizer::token::TokenTypes};
+use crate::db::table::Value;
 use hex::decode;
 
 // Returns an error if the current token does not match the given token type

src/cli/ast/create_statement.rs

@@ -1,4 +1,5 @@
-use crate::cli::{ast::{parser::Parser, CreateTableStatement, SqlStatement::{self, CreateTable}, common::expect_token_type}, table::{ColumnDefinition, DataType}, tokenizer::token::TokenTypes};
+use crate::cli::{ast::{parser::Parser, CreateTableStatement, SqlStatement::{self, CreateTable}, common::expect_token_type}, tokenizer::token::TokenTypes};
+use crate::db::table::{ColumnDefinition, DataType};
 
 pub fn build(parser: &mut Parser) -> Result<SqlStatement, String> {
     parser.advance()?;
@@ -36,7 +37,7 @@ fn table_statement(parser: &mut Parser) -> Result<SqlStatement, String> {
 }
 
 fn column_definitions(parser: &mut Parser) -> Result<Vec<ColumnDefinition>, String> {
-    let mut columns: Vec<crate::cli::table::ColumnDefinition> = vec![];
+    let mut columns: Vec<ColumnDefinition> = vec![];
 
     expect_token_type(parser, TokenTypes::LeftParen)?;
     parser.advance()?;

src/cli/ast/insert_statement.rs

@@ -1,4 +1,5 @@
-use crate::cli::{ast::{parser::Parser, common::token_to_value, common::expect_token_type, InsertIntoStatement, SqlStatement::{self, InsertInto}}, table::Value, tokenizer::token::TokenTypes};
+use crate::cli::{ast::{parser::Parser, common::token_to_value, common::expect_token_type, InsertIntoStatement, SqlStatement::{self, InsertInto}}, tokenizer::token::TokenTypes};
+use crate::db::table::Value;
 
 pub fn build(parser: &mut Parser) -> Result<SqlStatement, String> {
     parser.advance()?;

src/cli/ast/mod.rs

@@ -1,4 +1,5 @@
-use crate::cli::{self, table::{ColumnDefinition, Value}, tokenizer::token::TokenTypes};
+use crate::cli::tokenizer::{scanner::Token, token::TokenTypes};
+use crate::db::table::{ColumnDefinition, Value};
 
 mod common;
 mod create_statement;
@@ -98,7 +99,7 @@ impl StatementBuilder for DefaultStatementBuilder {
     }
 }
 
-pub fn generate(tokens: Vec<cli::tokenizer::scanner::Token>) -> Vec<Result<SqlStatement, String>> {
+pub fn generate(tokens: Vec<Token>) -> Vec<Result<SqlStatement, String>> {
     let mut results: Vec<Result<SqlStatement, String>> = vec![];
     let mut parser = parser::Parser::new(tokens);
     let builder : &dyn StatementBuilder = &DefaultStatementBuilder;

src/cli/ast/select_statement.rs

@@ -41,7 +41,6 @@ fn get_table_name(parser: &mut Parser) -> Result<String, String> {
     Ok(result)
 }
 
-
 fn get_where_clause(parser: &mut Parser) -> Result<Option<WhereClause>, String> {
     if expect_token_type(parser, TokenTypes::Where).is_err() {
         return Ok(None);
@@ -153,7 +152,7 @@ fn get_limit(parser: &mut Parser) -> Result<Option<LimitClause>, String> {
 mod tests {
     use super::*;
     use crate::cli::tokenizer::scanner::Token;
-    use crate::cli::table::Value;
+    use crate::db::table::Value;
 
     fn token(tt: TokenTypes, val: &'static str) -> Token<'static> {
         Token {

src/cli/mod.rs

@@ -1,12 +1,13 @@
 use std::io;
-mod ast;
-mod table;
+use crate::db;
+pub mod ast;
 mod tokenizer;
 
 pub fn cli() {
     clear_screen();
     println!("Welcome to the MollyDB CLI");
     let mut line_count = 1;
+    let mut database = db::database::Database::new();
 
     loop {
         print!("({:03}) > ", line_count);
@@ -31,8 +32,29 @@ pub fn cli() {
         let tokens = tokenizer::tokenize(input);
         println!("{:?}", tokens);
         let ast = ast::generate(tokens);
-        for result in ast {
-            println!("{:?}", result);
+        for sql_statement in ast {
+            println!("{:?}", sql_statement);
+            match sql_statement {
+                Ok(statement) => {
+                    let result = database.execute(statement);
+                    if let Ok(values) = result {
+                        if let Some(rows) = values {
+                            for row in rows {
+                                println!("{:?}", row);
+                            }
+                        }
+                        else {
+                            println!("Executed Successfully");
+                        }
+                    }
+                    else {
+                        println!("Error: {}", result.unwrap_err());
+                    }
+                },
+                Err(error) => {
+                    println!("Error: {}", error);
+                },
+            }
         }
     }
 }

src/db/database.rs

@@ -0,0 +1,71 @@
+use crate::db::table::{Table, Value};
+use crate::cli::ast::{SqlStatement, CreateTableStatement, InsertIntoStatement, SelectStatement};
+use std::collections::HashMap;
+
+pub struct Database {
+    tables: HashMap<String, Table>,
+}
+
+impl Database {
+    pub fn new() -> Self {
+        Self {
+            tables: HashMap::new(),
+        }
+    }
+
+    pub fn execute(&mut self, sql_statement: SqlStatement) -> Result<Option<Vec<Vec<Value>>>, String> {
+        return match sql_statement {
+            SqlStatement::CreateTable(statement) => {
+                self.create_table(statement)?;
+                Ok(None)
+            },
+            SqlStatement::InsertInto(statement) => {
+                self.insert_into_table(statement)?;
+                Ok(None)
+            },
+            SqlStatement::Select(statement) => {
+                let rows = self.select_from_table(statement)?;
+                Ok(Some(rows))
+            },
+        }
+    }
+
+    fn create_table(&mut self, statement: CreateTableStatement) -> Result<(), String> {
+        if self.has_table(&statement.table_name) {
+            return Err(format!("Table {} already exists", statement.table_name));
+        }
+        let table_name = statement.table_name;
+        self.tables.insert(table_name.clone(), Table::new(table_name, statement.columns));
+        Ok(())
+    }
+
+    fn insert_into_table(&mut self, statement: InsertIntoStatement) -> Result<(), String> {
+        let table = self.get_table_mut(&statement.table_name)?;
+        table.insert(statement)?;
+        Ok(())
+    }
+
+    fn select_from_table(&mut self, statement: SelectStatement) -> Result<Vec<Vec<Value>>, String> {
+        let table = self.get_table(&statement.table_name)?;
+        let rows = table.select(statement)?;
+        Ok(rows)
+    }
+
+    fn has_table(&self, table_name: &str) -> bool {
+        self.tables.contains_key(table_name)
+    }
+
+    fn get_table(&self, table_name: &str) -> Result<&Table, String> {
+        if !self.has_table(table_name) {
+            return Err(format!("Table {} does not exist", table_name));
+        }
+        Ok(self.tables.get(table_name).unwrap())
+    }
+
+    fn get_table_mut(&mut self, table_name: &str) -> Result<&mut Table, String> {
+        if !self.has_table(table_name) {
+            return Err(format!("Table {} does not exist", table_name));
+        }
+        Ok(self.tables.get_mut(table_name).unwrap())
+    }
+}

src/db/mod.rs

@@ -0,0 +1,2 @@
+pub mod database;
+pub mod table;