Compile where clauses!

src/ast.rs

 }
 
 #[derive(Debug, PartialEq)]
-pub enum Where {
-    And(Vec<Where>),
-    Equals(KValue, KValue),
+pub struct Where {
+    pub predicates: Vec<Equals>,
+}
+
+impl Where {
+    pub fn new(predicates: Vec<Equals>) -> Self {
+        Self { predicates }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Equals {
+    pub left: KIdentifier,
+    pub right: KValue,
+}
+
+impl Equals {
+    pub fn new(left: KIdentifier, right: KValue) -> Self {
+        Self { left, right }
+    }
 }
 
 #[derive(Debug, PartialEq)]
 
 #[derive(Debug, PartialEq)]
 pub struct KNumber {
-    pub value: f32,
+    pub value: f64,
 }
 
 #[derive(Debug, PartialEq)]
 }
 
 impl KNumber {
-    pub fn new(value: f32) -> Self {
+    pub fn new(value: f64) -> Self {
         Self { value }
     }
 }

src/compiler.rs

 
 use std::fmt::{Display, Formatter};
 
-use crate::ast::{Field, KIdentifier, Select};
+use crate::ast::{Field, KIdentifier, KValue, Select, Where};
 use crate::error::KappeError;
 
 #[derive(Debug, PartialEq)]
         })
         .collect();
 
+    let query = if let Some(where_clause) = expr.where_clause {
+        compile_where_clause(where_clause)
+    } else {
+        json!({ "match_all":{} })
+    };
+
     let body = json!({
-        "query": { "match_all":{} },
+        "query": query,
         "_source": Value::Array(field_names)
     });
 
     Ok(Query::new(expr.source, body))
 }
 
+pub fn compile_where_clause(where_clause: Where) -> Value {
+    let terms: Vec<Value> = where_clause
+        .predicates
+        .iter()
+        .map(|predicate| {
+            let mut map = serde_json::Map::new();
+            let key = predicate.left.name.clone();
+            let value = compile_kvalue(&predicate.right);
+            map.insert(key, value);
+            json!({ "term": Value::Object(map) })
+        })
+        .collect();
+
+    json!({
+        "bool": {
+            "filter": Value::Array(terms)
+        }
+    })
+}
+
+pub fn compile_kvalue(value: &KValue) -> Value {
+    match value {
+        KValue::Identifier(identifier) => Value::String(identifier.name.to_string()),
+        KValue::Number(number) => {
+            Value::Number(serde_json::Number::from_f64(number.value).unwrap())
+        }
+        KValue::String(string) => Value::String(string.value.to_string()),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
             )
         )
     }
+
+    #[test]
+    fn it_compiles_a_select_with_a_single_predicate_where_clause() {
+        let mut map: serde_json::Map<String, Value> = serde_json::Map::new();
+        map.insert("baz".to_string(), Value::String("quux".to_string()));
+        assert_eq!(
+            _compile("SELECT * FROM bar WHERE baz = \"quux\"").unwrap(),
+            Query::new(
+                KIdentifier::new("bar"),
+                json!({
+                    "query": {
+                        "bool": {
+                            "filter": [
+                                json!({ "term": Value::Object(map) })
+                            ]
+                        }
+                    },
+                    "_source": ["*"]
+                })
+            )
+        )
+    }
+
+    #[test]
+    fn it_compiles_a_select_with_a_multiple_predicate_where_claus() {
+        let mut map_one: serde_json::Map<String, Value> = serde_json::Map::new();
+        map_one.insert("baz".to_string(), Value::String("quux".to_string()));
+        let mut map_two: serde_json::Map<String, Value> = serde_json::Map::new();
+        map_two.insert(
+            "bop".to_string(),
+            Value::Number(serde_json::Number::from_f64(5.0).unwrap()),
+        );
+        assert_eq!(
+            _compile("SELECT * FROM bar WHERE baz = \"quux\", bop = 5").unwrap(),
+            Query::new(
+                KIdentifier::new("bar"),
+                json!({
+                    "query": {
+                        "bool": {
+                            "filter": [
+                                json!({ "term": Value::Object(map_one) }),
+                                json!({ "term": Value::Object(map_two) }),
+                            ]
+                        }
+                    },
+                    "_source": ["*"]
+                })
+            )
+        )
+    }
 }

src/parser.rs

 use std::{iter::Peekable, slice::Iter};
 
-use crate::ast::{Field, KIdentifier, KNumber, KString, KValue, Select, Where};
+use crate::ast::{Equals, Field, KIdentifier, KNumber, KString, KValue, Select, Where};
 use crate::error::KappeError;
 use crate::token::{Token, TokenType};
 
 }
 
 fn parse_where_clause(tokens: &mut Peekable<Iter<Token>>) -> Result<Option<Where>, KappeError> {
+    let mut predicates: Vec<Equals> = vec![];
     let where_clause = if current_token_is(tokens, TokenType::Where) {
         eat(tokens, TokenType::Where)?;
 
         let predicate = parse_predicate(tokens)?;
+        predicates.push(predicate);
 
         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)
         }
+
+        Some(Where::new(predicates))
     } else {
         None
     };
     Ok(where_clause)
 }
 
-fn parse_predicate(tokens: &mut Peekable<Iter<Token>>) -> Result<Where, KappeError> {
+fn parse_predicate(tokens: &mut Peekable<Iter<Token>>) -> Result<Equals, KappeError> {
     let field = eat(tokens, TokenType::Identfiier)?;
-    let field = KValue::Identifier(KIdentifier::new(&field.value));
+    let field = KIdentifier::new(&field.value);
 
     eat(tokens, TokenType::Equals)?;
 
         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>() {
+        match token.value.parse::<f64>() {
             Ok(n) => Ok(KValue::Number(KNumber::new(n))),
-            Err(_) => Err(KappeError::new("Error converting number to f32")),
+            Err(_) => Err(KappeError::new("Error converting number to f64")),
         }
     } else {
         Err(KappeError::new(
         ))
     }?;
 
-    Ok(Where::Equals(field, value))
+    Ok(Equals::new(field, value))
 }
 
 fn current_token_is(tokens: &mut Peekable<Iter<Token>>, token_type: TokenType) -> bool {
             Select {
                 fields: vec![Field::Star],
                 source: KIdentifier::new("index"),
-                where_clause: Some(Where::Equals(
-                    KValue::Identifier(KIdentifier::new("field")),
+                where_clause: Some(Where::new(vec![Equals::new(
+                    KIdentifier::new("field"),
                     KValue::String(KString::new("hello")),
-                ))
+                )]))
             },
         )
     }
             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)),
-                ))
+                where_clause: Some(Where::new(vec![Equals::new(
+                    KIdentifier::new("field"),
+                    KValue::Number(KNumber::new(123.0))
+                ),]))
             },
         )
     }
             Select {
                 fields: vec![Field::Star],
                 source: KIdentifier::new("index"),
-                where_clause: Some(Where::And(vec![
-                    Where::Equals(
-                        KValue::Identifier(KIdentifier::new("field_one")),
+                where_clause: Some(Where::new(vec![
+                    Equals::new(
+                        KIdentifier::new("field_one"),
                         KValue::String(KString::new("hello")),
                     ),
-                    Where::Equals(
-                        KValue::Identifier(KIdentifier::new("field_two")),
+                    Equals::new(
+                        KIdentifier::new("field_two"),
                         KValue::String(KString::new("world")),
                     )
                 ]))