AST - Refactor Parser Testing and Helpers

src/cli/ast/create_statement.rs

@@ -1,4 +1,10 @@
-use crate::cli::{ast::{parser::Parser, CreateTableStatement, SqlStatement::{self, CreateTable}, common::expect_token_type}, tokenizer::token::TokenTypes};
+use crate::cli::{
+    ast::{
+        parser::Parser, CreateTableStatement, SqlStatement::{self, CreateTable}, 
+        helpers::common::{expect_token_type, get_table_name}
+    }, 
+    tokenizer::token::TokenTypes
+};
 use crate::db::table::{ColumnDefinition, DataType};
 
 pub fn build(parser: &mut Parser) -> Result<SqlStatement, String> {
@@ -22,11 +28,8 @@ pub fn build(parser: &mut Parser) -> Result<SqlStatement, String> {
 }
 
 fn table_statement(parser: &mut Parser) -> Result<SqlStatement, String> {
-    parser.advance()?;
-
-    let token = parser.current_token()?;
-    expect_token_type(parser, TokenTypes::Identifier)?;
-    let table_name = token.value.to_string();
+    // Get the table name
+    let table_name = get_table_name(parser)?;
     parser.advance()?;
 
     let column_definitions = column_definitions(parser)?;
@@ -100,16 +103,7 @@ fn index_statement(_parser: &mut Parser) -> Result<SqlStatement, String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::cli::tokenizer::scanner::Token;
-
-    fn token(tt: TokenTypes, val: &'static str) -> Token<'static> {
-        Token {
-            token_type: tt,
-            value: val,
-            col_num: 0,
-            line_num: 1,
-        }
-    }
+    use crate::cli::ast::test_utils::token;
 
     #[test]
     fn create_table_generates_proper_statement(){

src/cli/ast/delete_statement.rs

@@ -1,5 +1,13 @@
-use crate::cli::ast::{parser::Parser, SqlStatement, DeleteStatement, common::{expect_token_type, get_table_name, get_where_clause, get_order_by, get_limit}};
-use crate::cli::tokenizer::token::TokenTypes;
+use crate::cli::{
+    ast::{
+        parser::Parser, SqlStatement, DeleteStatement, 
+        helpers::{
+            common::{expect_token_type, get_table_name},
+            order_by_clause::get_order_by, where_clause::get_where_clause, limit_clause::get_limit
+        }
+    },
+    tokenizer::token::TokenTypes
+};
 
 pub fn build(parser: &mut Parser) -> Result<SqlStatement, String> {
     parser.advance()?;
@@ -21,23 +29,14 @@ pub fn build(parser: &mut Parser) -> Result<SqlStatement, String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::cli::tokenizer::scanner::Token;
+    use crate::cli::ast::test_utils::token;
     use crate::cli::ast::OrderByClause;
     use crate::cli::ast::OrderByDirection;
     use crate::cli::ast::LimitClause;
     use crate::cli::ast::Operator;
     use crate::cli::ast::WhereClause;
     use crate::db::table::Value;
 
-    fn token(tt: TokenTypes, val: &'static str) -> Token<'static> {
-        Token {
-            token_type: tt,
-            value: val,
-            col_num: 0,
-            line_num: 1,
-        }
-    }
-
     #[test]
     fn delete_statement_with_all_tokens_is_generated_correctly() {
         // DELETE FROM users;

src/cli/ast/helpers/common.rs

@@ -0,0 +1,64 @@
+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
+pub fn expect_token_type(parser: &Parser, token_type: TokenTypes) -> Result<(), String> {
+    let token = parser.current_token()?;
+    if token.token_type != token_type {
+        return Err(parser.format_error());
+    }
+    Ok(())
+}
+
+pub fn token_to_value(parser: &Parser) -> Result<Value, String> {
+    let token = parser.current_token()?;
+
+    match token.token_type {
+        TokenTypes::IntLiteral => {
+            let num = token.value.parse::<i64>()
+                .map_err(|_| parser.format_error())?;
+            Ok(Value::Integer(num))
+        },
+        TokenTypes::RealLiteral => {
+            let num = token.value.parse::<f64>()
+                .map_err(|_| parser.format_error())?;
+            Ok(Value::Real(num))
+        },
+        TokenTypes::String => Ok(Value::Text(token.value.to_string())),
+        TokenTypes::Blob => {
+            let bytes = decode(token.value)
+                .map_err(|_| parser.format_error())?;
+            Ok(Value::Blob(bytes))
+        },
+        TokenTypes::Null => Ok(Value::Null),
+        _ => Err(parser.format_error()),
+    }
+}
+
+// Returns a list of Strings from the tokens when they are formated as "identifier, identifier, ..."
+pub fn tokens_to_identifier_list(parser: &mut Parser) -> Result<Vec<String>, String> {
+    let mut identifiers: Vec<String> = vec![];
+    loop {
+        let token = parser.current_token()?;
+        expect_token_type(parser, TokenTypes::Identifier)?;
+
+        identifiers.push(token.value.to_string());
+        parser.advance()?;
+        let token = parser.current_token()?;
+        if token.token_type != TokenTypes::Comma {
+            break;
+        }
+        parser.advance()?;
+    }
+    return Ok(identifiers);
+}
+
+pub fn get_table_name(parser: &mut Parser) -> Result<String, String> {
+    parser.advance()?;
+    let token = parser.current_token()?;
+    expect_token_type(parser, TokenTypes::Identifier)?;
+    let result = token.value.to_string();
+    Ok(result)
+}