sql_parser: update statement parser implemented

Author: Almaz-KG

src/ast/alter.rs

@@ -69,7 +69,7 @@ pub struct PrimaryKeyConstraint {
 /// Do not get confused with the conflict clause in the
 /// [RaiseFunction](https://www.sqlite.org/lang_raise.html) as they look similar
 /// but they are different.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum ConflictClause {
     /// No conflict clause
     None,

src/ast/delete.rs

@@ -1,7 +1,7 @@
 use super::{Expression, LimitClause, OrderingTerm, QualifiedTableName};
 
 /// An AST for [DELETE](https://www.sqlite.org/lang_delete.html) SQL statement.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct DeleteStatement {
     /// The table name to delete from
     pub table_name: QualifiedTableName,
@@ -20,7 +20,7 @@ pub struct DeleteStatement {
 }
 
 /// A [RETURNING](https://www.sqlite.org/lang_returning.html) clause types
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum ReturningClause {
     /// A single expression
     Expr(Expression),

src/ast/mod.rs

@@ -35,7 +35,7 @@ pub use trx::{
     BeginTransactionStatement, CommitTransactionStatement, ReleaseStatement,
     RollbackTransactionStatement, SavepointStatement, TransactionType,
 };
-pub use update::UpdateStatement;
+pub use update::*;
 
 /// Top-level AST node representing any SQLite statement
 #[derive(Debug, PartialEq)]

src/ast/update.rs

@@ -3,11 +3,11 @@ use super::{
 };
 
 /// An AST for [UPDATE SQL](https://www.sqlite.org/lang_update.html) statement.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct UpdateStatement {
     // The conflict clause defined after the OR keyword is used to specify the
     // behavior of the UPDATE statement when a constraint violation occurs.
-    pub conflict_clause: Option<ConflictClause>,
+    pub conflict_clause: ConflictClause,
 
     // The table name to update.
     pub table_name: QualifiedTableName,
@@ -19,18 +19,18 @@ pub struct UpdateStatement {
     pub from_clause: Option<FromClause>,
 
     // The where clause to filter the rows to update.
-    pub where_clause: Option<Expression>,
+    pub where_clause: Option<Box<Expression>>,
 
     // The returning clause to return the updated rows.
-    pub returning_clause: Option<ReturningClause>,
+    pub returning_clause: Vec<ReturningClause>,
 }
 
 /// A [SetClause](https://www.sqlite.org/syntax/set-clause.html)
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum SetClause {
     /// A single column assignment, e.g. `column = expression`.
     ColumnAssignment(Identifier, Expression),
 
     /// A multiple column assignment, e.g. `(column1, column2) = expression`.
-    MultipleColumnAssignment((Vec<Identifier>, Expression)),
+    MultipleColumnAssignment(Vec<Identifier>, Expression),
 }

src/parser/select/mod.rs

@@ -27,18 +27,15 @@ pub trait SelectStatementParser {
 
     fn parse_select_column(&mut self) -> Result<SelectItem, ParsingError>;
 
-    fn parse_select_from_clause(&mut self) -> Result<Option<FromClause>, ParsingError>;
+    fn parse_from_clause(&mut self) -> Result<Option<FromClause>, ParsingError>;
 
-    fn parse_select_from_clause_subquery(&mut self) -> Result<FromClause, ParsingError>;
+    fn parse_from_clause_subquery(&mut self) -> Result<FromClause, ParsingError>;
 
-    fn parse_select_from_join_clause(
-        &mut self,
-        lhs: FromClause,
-    ) -> Result<FromClause, ParsingError>;
+    fn parse_from_join_clause(&mut self, lhs: FromClause) -> Result<FromClause, ParsingError>;
 
-    fn parse_select_from_clause_join_type(&mut self) -> Result<JoinType, ParsingError>;
+    fn parse_from_clause_join_type(&mut self) -> Result<JoinType, ParsingError>;
 
-    fn parse_select_from_clause_join_constraints(
+    fn parse_from_clause_join_constraints(
         &mut self,
     ) -> Result<Option<JoinConstraint>, ParsingError>;
 
@@ -92,7 +89,7 @@ impl<'a> SelectStatementParser for Parser<'a> {
         Ok(SelectStatement::Select(Select {
             distinct_type: self.parse_distinct_type()?,
             columns: self.parse_select_columns()?,
-            from: self.parse_select_from_clause()?,
+            from: self.parse_from_clause()?,
             where_clause: self.parse_where_clause()?,
             group_by: self.parse_group_by_clause()?,
             having: self.parse_having_clause()?,
@@ -157,15 +154,15 @@ impl<'a> SelectStatementParser for Parser<'a> {
         ))
     }
 
-    fn parse_select_from_clause(&mut self) -> Result<Option<FromClause>, ParsingError> {
+    fn parse_from_clause(&mut self) -> Result<Option<FromClause>, ParsingError> {
         if let Ok(Keyword::From) = self.peek_as_keyword() {
             self.consume_as_keyword(Keyword::From)?;
-            return Ok(Some(self.parse_select_from_clause_subquery()?));
+            return Ok(Some(self.parse_from_clause_subquery()?));
         }
         Ok(None)
     }
 
-    fn parse_select_from_clause_subquery(&mut self) -> Result<FromClause, ParsingError> {
+    fn parse_from_clause_subquery(&mut self) -> Result<FromClause, ParsingError> {
         dbg!("parse_select_from_clause");
 
         dbg!(&self.peek_token());
@@ -186,7 +183,7 @@ impl<'a> SelectStatementParser for Parser<'a> {
                 let mut froms = Vec::new();
                 loop {
                     dbg!("parse_select_from_clause");
-                    let table_or_subquery = self.parse_select_from_clause_subquery()?;
+                    let table_or_subquery = self.parse_from_clause_subquery()?;
                     dbg!(&table_or_subquery);
                     froms.push(table_or_subquery);
 
@@ -224,7 +221,7 @@ impl<'a> SelectStatementParser for Parser<'a> {
                     indexed_type,
                 });
 
-                return self.parse_select_from_join_clause(lhs);
+                return self.parse_from_join_clause(lhs);
             }
         }
         // TODO: improve this error message
@@ -233,19 +230,16 @@ impl<'a> SelectStatementParser for Parser<'a> {
         ))
     }
 
-    fn parse_select_from_join_clause(
-        &mut self,
-        lhs: FromClause,
-    ) -> Result<FromClause, ParsingError> {
+    fn parse_from_join_clause(&mut self, lhs: FromClause) -> Result<FromClause, ParsingError> {
         dbg!("parse_select_from_join_clause");
         let mut join_tables = Vec::new();
 
-        while let Ok(join_type) = self.parse_select_from_clause_join_type() {
-            let rhs = self.parse_select_from_clause_subquery()?;
+        while let Ok(join_type) = self.parse_from_clause_join_type() {
+            let rhs = self.parse_from_clause_subquery()?;
             join_tables.push(JoinTable {
                 join_type,
                 table: Box::new(rhs),
-                constraints: self.parse_select_from_clause_join_constraints()?,
+                constraints: self.parse_from_clause_join_constraints()?,
             });
         }
 
@@ -259,7 +253,7 @@ impl<'a> SelectStatementParser for Parser<'a> {
         }))
     }
 
-    fn parse_select_from_clause_join_type(&mut self) -> Result<JoinType, ParsingError> {
+    fn parse_from_clause_join_type(&mut self) -> Result<JoinType, ParsingError> {
         let natural_join = self.consume_as_keyword(Keyword::Natural).is_ok();
 
         if self.consume_as(TokenType::Comma).is_ok() {
@@ -316,7 +310,7 @@ impl<'a> SelectStatementParser for Parser<'a> {
         }
     }
 
-    fn parse_select_from_clause_join_constraints(
+    fn parse_from_clause_join_constraints(
         &mut self,
     ) -> Result<Option<JoinConstraint>, ParsingError> {
         if self.consume_as_keyword(Keyword::On).is_ok() {