Parse where clauses

src/ast.rs

@@ -0,0 +1,62 @@
+#[derive(Debug, PartialEq)]
+pub struct Select {
+    pub fields: Vec<Field>,
+    pub source: KIdentifier,
+    pub where_clause: Option<Where>,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Field {
+    Named(String),
+    Star,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Where {
+    And(Vec<Where>),
+    Equals(KValue, KValue),
+}
+
+#[derive(Debug, PartialEq)]
+pub enum KValue {
+    Identifier(KIdentifier),
+    Number(KNumber),
+    String(KString),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct KIdentifier {
+    pub name: String,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct KNumber {
+    pub value: f32,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct KString {
+    pub value: String,
+}
+
+impl KIdentifier {
+    pub fn new(name: &str) -> Self {
+        Self {
+            name: name.to_string(),
+        }
+    }
+}
+
+impl KNumber {
+    pub fn new(value: f32) -> Self {
+        Self { value }
+    }
+}
+
+impl KString {
+    pub fn new(value: &str) -> Self {
+        Self {
+            value: value.to_string(),
+        }
+    }
+}

src/compiler.rs

@@ -2,17 +2,17 @@ use serde_json::{json, Value};
 
 use std::fmt::{Display, Formatter};
 
+use crate::ast::{Field, KIdentifier, Select};
 use crate::error::KappeError;
-use crate::parser::{Field, Identifier, Select};
 
 #[derive(Debug, PartialEq)]
 pub struct Query {
-    pub source: Identifier,
+    pub source: KIdentifier,
     pub body: Value,
 }
 
 impl Query {
-    pub fn new(source: Identifier, body: Value) -> Self {
+    pub fn new(source: KIdentifier, body: Value) -> Self {
         Self { source, body }
     }
 }
@@ -63,7 +63,7 @@ mod tests {
         assert_eq!(
             _compile("SELECT * FROM bar").unwrap(),
             Query::new(
-                Identifier::new("bar"),
+                KIdentifier::new("bar"),
                 json!({
                     "query": {
                         "match_all": {}
@@ -79,7 +79,7 @@ mod tests {
         assert_eq!(
             _compile("SELECT foo FROM bar").unwrap(),
             Query::new(
-                Identifier::new("bar"),
+                KIdentifier::new("bar"),
                 json!({
                     "query": {
                         "match_all": {}

src/lib.rs

@@ -1,3 +1,4 @@
+pub mod ast;
 pub mod compiler;
 pub mod error;
 pub mod lexer;

src/parser.rs

@@ -1,33 +1,9 @@
 use std::{iter::Peekable, slice::Iter};
 
+use crate::ast::{Field, KIdentifier, KNumber, KString, KValue, Select, Where};
 use crate::error::KappeError;
 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 {
-    Named(String),
-    Star,
-}
-
-impl Identifier {
-    pub fn new(name: &str) -> Self {
-        Self {
-            name: name.to_string(),
-        }
-    }
-}
-
 pub fn parse(tokens: Vec<Token>) -> Result<Select, KappeError> {
     parse_select_expression(&mut tokens.iter().peekable())
 }
@@ -36,9 +12,15 @@ fn parse_select_expression(tokens: &mut Peekable<Iter<Token>>) -> Result<Select,
     eat(tokens, TokenType::Select)?;
     let fields = parse_fields(tokens)?;
     eat(tokens, TokenType::From)?;
-    let source = eat(tokens, TokenType::Identfiier).and_then(|t| Ok(Identifier::new(&t.value)))?;
+    let source = eat(tokens, TokenType::Identfiier).and_then(|t| Ok(KIdentifier::new(&t.value)))?;
+
+    let where_clause = parse_where_clause(tokens)?;
 
-    Ok(Select { fields, source })
+    Ok(Select {
+        fields,
+        source,
+        where_clause,
+    })
 }
 
 fn parse_fields(tokens: &mut Peekable<Iter<Token>>) -> Result<Vec<Field>, KappeError> {
@@ -62,6 +44,57 @@ fn parse_fields(tokens: &mut Peekable<Iter<Token>>) -> Result<Vec<Field>, KappeE
     }
 }
 
+fn parse_where_clause(tokens: &mut Peekable<Iter<Token>>) -> Result<Option<Where>, KappeError> {
+    let where_clause = if current_token_is(tokens, TokenType::Where) {
+        eat(tokens, TokenType::Where)?;
+
+        let predicate = parse_predicate(tokens)?;
+
+        if current_token_is(tokens, TokenType::Comma) {
+            let mut predicates: Vec<Where> = vec![];
+            predicates.push(predicate);
+
+            while current_token_is(tokens, TokenType::Comma) {
+                eat(tokens, TokenType::Comma)?;
+                let predicate = parse_predicate(tokens)?;
+                predicates.push(predicate);
+            }
+
+            Some(Where::And(predicates))
+        } else {
+            Some(predicate)
+        }
+    } else {
+        None
+    };
+
+    Ok(where_clause)
+}
+
+fn parse_predicate(tokens: &mut Peekable<Iter<Token>>) -> Result<Where, KappeError> {
+    let field = eat(tokens, TokenType::Identfiier)?;
+    let field = KValue::Identifier(KIdentifier::new(&field.value));
+
+    eat(tokens, TokenType::Equals)?;
+
+    let value: KValue = if current_token_is(tokens, TokenType::String) {
+        let token = eat(tokens, TokenType::String)?;
+        Ok(KValue::String(KString::new(&token.value)))
+    } else if current_token_is(tokens, TokenType::Number) {
+        let token = eat(tokens, TokenType::Number)?;
+        match token.value.parse::<f32>() {
+            Ok(n) => Ok(KValue::Number(KNumber::new(n))),
+            Err(_) => Err(KappeError::new("Error converting number to f32")),
+        }
+    } else {
+        Err(KappeError::new(
+            "Invalid token on right-hand side of equals sign",
+        ))
+    }?;
+
+    Ok(Where::Equals(field, value))
+}
+
 fn current_token_is(tokens: &mut Peekable<Iter<Token>>, token_type: TokenType) -> bool {
     match tokens.peek() {
         Some(t) => t.token_type == token_type,
@@ -104,7 +137,8 @@ mod tests {
             _parse("SELECT * FROM index").unwrap(),
             Select {
                 fields: vec![Field::Star],
-                source: Identifier::new("index")
+                source: KIdentifier::new("index"),
+                where_clause: None
             },
         )
     }
@@ -115,7 +149,8 @@ mod tests {
             _parse("SELECT field FROM index").unwrap(),
             Select {
                 fields: vec![Field::Named("field".to_string())],
-                source: Identifier::new("index")
+                source: KIdentifier::new("index"),
+                where_clause: None
             },
         )
     }
@@ -129,7 +164,60 @@ mod tests {
                     Field::Named("field_one".to_string()),
                     Field::Named("field_two".to_string())
                 ],
-                source: Identifier::new("index")
+                source: KIdentifier::new("index"),
+                where_clause: None
+            },
+        )
+    }
+
+    #[test]
+    fn it_parses_a_select_with_a_single_predicate_where_clause() {
+        assert_eq!(
+            _parse("SELECT * FROM index WHERE field = \"hello\"").unwrap(),
+            Select {
+                fields: vec![Field::Star],
+                source: KIdentifier::new("index"),
+                where_clause: Some(Where::Equals(
+                    KValue::Identifier(KIdentifier::new("field")),
+                    KValue::String(KString::new("hello")),
+                ))
+            },
+        )
+    }
+
+    #[test]
+    fn it_parses_a_select_with_a_numeric_predicate() {
+        assert_eq!(
+            _parse("SELECT * FROM index WHERE field = 123").unwrap(),
+            Select {
+                fields: vec![Field::Star],
+                source: KIdentifier::new("index"),
+                where_clause: Some(Where::Equals(
+                    KValue::Identifier(KIdentifier::new("field")),
+                    KValue::Number(KNumber::new(123.0)),
+                ))
+            },
+        )
+    }
+
+    #[test]
+    fn it_parses_a_select_with_a_multiple_predicate_where_clause() {
+        assert_eq!(
+            _parse("SELECT * FROM index WHERE field_one = \"hello\", field_two = \"world\"")
+                .unwrap(),
+            Select {
+                fields: vec![Field::Star],
+                source: KIdentifier::new("index"),
+                where_clause: Some(Where::And(vec![
+                    Where::Equals(
+                        KValue::Identifier(KIdentifier::new("field_one")),
+                        KValue::String(KString::new("hello")),
+                    ),
+                    Where::Equals(
+                        KValue::Identifier(KIdentifier::new("field_two")),
+                        KValue::String(KString::new("world")),
+                    )
+                ]))
             },
         )
     }