Implemented DELETE keyword. Not much to do, all of the subexpressions were already handled

src/sqlast.rs

@@ -56,6 +56,12 @@ pub enum ASTNode {
         having: Option<Box<ASTNode>>,
         limit: Option<Box<ASTNode>>,
     },
+    SQLDelete {
+        relation: Option<Box<ASTNode>>,     // FROM statement
+        selection: Option<Box<ASTNode>>,    // WHERE statement
+        order_by: Option<Vec<ASTNode>>,
+        limit: Option<Box<ASTNode>>,
+    },
     SQLCreateTable {
         /// Table name
         name: String,

src/sqlparser.rs

@@ -87,6 +87,7 @@ impl Parser {
                     Token::Keyword(k) => match k.to_uppercase().as_ref() {
                         "SELECT" => Ok(self.parse_select()?),
                         "CREATE" => Ok(self.parse_create()?),
+                        "DELETE" => Ok(self.parse_delete()?),
                         _ => return parser_err!(format!("No prefix parser for keyword {}", k)),
                     },
                     Token::Mult => Ok(ASTNode::SQLWildcard),
@@ -440,6 +441,49 @@ impl Parser {
         }
     }
 
+    pub fn parse_delete(&mut self) -> Result<ASTNode, ParserError> {
+
+        let relation:  Option<Box<ASTNode>> = if self.parse_keyword("FROM") {
+            Some(Box::new(self.parse_expr(0)?))
+        } else {
+            None
+        };
+
+        let order_by = if self.parse_keywords(vec!["ORDER", "BY"]) {
+            Some(self.parse_order_by_expr_list()?)
+        } else {
+            None
+        };
+
+        let limit = if self.parse_keyword("LIMIT") {
+            self.parse_limit()?
+        } else {
+            None
+        };
+
+        let selection = if self.parse_keyword("WHERE") {
+            Some(Box::new(self.parse_expr(0)?))
+        } else {
+            None
+        };
+
+        // parse next token
+        if let Some(next_token) = self.peek_token() {
+            parser_err!(format!(
+                "Unexpected token at end of DELETE: {:?}",
+                next_token
+            ))       
+        } else {
+            Ok(ASTNode::SQLDelete {
+                relation,
+                selection,
+                order_by,
+                limit,
+            })
+        }
+
+    }
+
     /// Parse a SELECT statement
     pub fn parse_select(&mut self) -> Result<ASTNode, ParserError> {
         let projection = self.parse_expr_list()?;
@@ -581,6 +625,56 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn parse_delete_statement() {
+        
+        let sql: &str = "DELETE FROM 'table'";
+
+        match parse_sql(&sql) {
+            
+            ASTNode::SQLDelete {
+                relation, 
+                ..
+            } => {
+                assert_eq!(Some(Box::new(ASTNode::SQLLiteralString("table".to_string()))), relation);
+            },
+
+            _ => assert!(false),
+        }
+    }
+
+    #[test]
+    fn parse_where_delete_statement() {
+        
+        let sql: &str = "DELETE FROM 'table' WHERE name = 5";
+
+        use self::ASTNode::*;
+        use self::SQLOperator::*;
+
+        match parse_sql(&sql) {
+            
+            ASTNode::SQLDelete {
+                relation,
+                selection,
+                ..
+            } => {
+                assert_eq!(Some(Box::new(ASTNode::SQLLiteralString("table".to_string()))), relation);
+                
+                assert_eq!(
+                    SQLBinaryExpr {
+                        left: Box::new(SQLIdentifier("name".to_string())),
+                        op: Eq,
+                        right: Box::new(SQLLiteralLong(5)),
+                    },
+                    *selection.unwrap(),
+                );
+
+            },
+
+            _ => assert!(false),
+        }
+    }
+
     #[test]
     fn parse_simple_select() {
         let sql = String::from("SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT 5");
@@ -851,6 +945,7 @@ mod tests {
 
     }
 
+
     #[test]
     fn parse_select_version() {
         let sql = "SELECT @@version";