Parse select statements

src/error.rs

@@ -5,6 +5,14 @@ pub struct LexerError {
     message: String,
 }
 
+impl LexerError {
+    pub fn new(message: &str) -> Self {
+        Self {
+            message: message.to_string(),
+        }
+    }
+}
+
 impl Display for LexerError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", &self.message)
@@ -13,14 +21,35 @@ impl Display for LexerError {
 
 impl Error for LexerError {}
 
-// impl Into<std::io::Error> for LexerError {
-//     fn into(self) -> std::io::Error {
-//         std::io::Error::new(std::io::ErrorKind::InvalidInput, self.message)
-//     }
-// }
-
 impl From<LexerError> for std::io::Error {
     fn from(e: LexerError) -> Self {
         Self::new(std::io::ErrorKind::InvalidInput, e.message)
     }
 }
+
+#[derive(Debug, PartialEq)]
+pub struct ParserError {
+    message: String,
+}
+
+impl ParserError {
+    pub fn new(message: &str) -> Self {
+        Self {
+            message: message.to_string(),
+        }
+    }
+}
+
+impl Display for ParserError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", &self.message)
+    }
+}
+
+impl Error for ParserError {}
+
+impl From<ParserError> for std::io::Error {
+    fn from(e: ParserError) -> Self {
+        Self::new(std::io::ErrorKind::InvalidInput, e.message)
+    }
+}

src/lib.rs

@@ -1,3 +1,4 @@
 pub mod error;
 pub mod lexer;
+pub mod parser;
 pub mod token;

src/parser.rs

@@ -0,0 +1,79 @@
+use std::slice::Iter;
+
+use crate::error::ParserError;
+use crate::token::{Token, TokenType};
+
+#[derive(Debug, PartialEq)]
+pub struct Select {
+    pub fields: Vec<Field>,
+    pub source: Identifier,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Identifier {
+    pub name: String,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Field {
+    Star,
+}
+
+impl Identifier {
+    pub fn new(name: &str) -> Self {
+        Self {
+            name: name.to_string(),
+        }
+    }
+}
+
+pub fn parse(tokens: Vec<Token>) -> Result<Select, ParserError> {
+    select_expression(&mut tokens.iter())
+}
+
+fn select_expression(tokens: &mut Iter<Token>) -> Result<Select, ParserError> {
+    eat(tokens, TokenType::Select)?;
+    let fields = eat(tokens, TokenType::Star).and_then(|_| Ok(vec![Field::Star]))?;
+    eat(tokens, TokenType::From)?;
+    let source = eat(tokens, TokenType::Identfiier).and_then(|t| Ok(Identifier::new(&t.value)))?;
+
+    Ok(Select { fields, source })
+}
+
+fn eat<'a>(tokens: &'a mut Iter<Token>, token_type: TokenType) -> Result<&'a Token, ParserError> {
+    match tokens.next() {
+        Some(token) => {
+            if token.token_type == token_type {
+                Ok(token)
+            } else {
+                Err(ParserError::new(&format!(
+                    "Expected {} but got {}",
+                    token_type, token.token_type
+                )))
+            }
+        }
+        None => Err(ParserError::new("Unexpected end of tokens")),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::lexer::scan;
+
+    fn _parse(input: &str) -> Result<Select, ParserError> {
+        let tokens = scan(input).unwrap();
+        parse(tokens)
+    }
+
+    #[test]
+    fn it_parses_a_simple_select() {
+        assert_eq!(
+            _parse("SELECT * FROM index").unwrap(),
+            Select {
+                fields: vec![Field::Star],
+                source: Identifier::new("index")
+            },
+        )
+    }
+}

src/token.rs

@@ -1,7 +1,7 @@
 #[derive(Debug, PartialEq)]
 pub struct Token {
-    token_type: TokenType,
-    value: String,
+    pub token_type: TokenType,
+    pub value: String,
 }
 
 impl Token {