sql_parser: ordering parser-refactoring

Author: Almaz-KG

src/parser/column/mod.rs

@@ -1,14 +1,11 @@
 use crate::{
     ColumnConstraint, ColumnConstraintType, ColumnDefinition, ConflictClause, Expression, FKAction,
     FKConstraintAction, FKDeferrableType, ForeignKeyClause, GeneratedColumnConstraint,
-    GeneratedColumnType, Identifier, Keyword, LiteralValue, Ordering, PrimaryKeyConstraint,
-    TokenType,
+    GeneratedColumnType, Identifier, Keyword, LiteralValue, PrimaryKeyConstraint, TokenType,
 };
 
-use super::{
-    expression::{DataTypeParser, ExpressionParser, IdentifierParser},
-    Parser, ParsingError,
-};
+use super::expression::{DataTypeParser, ExpressionParser, IdentifierParser};
+use super::{Parser, ParsingError};
 
 pub trait ColumnDefinitionParser {
     fn parse_column_definition(&mut self) -> Result<ColumnDefinition, ParsingError>;
@@ -82,13 +79,7 @@ impl<'a> ColumnDefinitionParser for Parser<'a> {
                 self.consume_as_keyword(Keyword::Primary)?;
                 self.consume_as_keyword(Keyword::Key)?;
 
-                let ordering = if self.consume_as_keyword(Keyword::Asc).is_ok() {
-                    Some(Ordering::Asc)
-                } else if self.consume_as_keyword(Keyword::Desc).is_ok() {
-                    Some(Ordering::Desc)
-                } else {
-                    None
-                };
+                let ordering = self.parse_ordering()?;
 
                 // Parse the optional on conflict clause
                 let conflict_clause = self.parse_on_conflict_clause()?;

src/parser/insert/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
     parser::select::SelectStatementParser, ConflictClause, Identifier, IndexedColumn,
-    InsertStatement, InsertValues, Keyword, Ordering, QualifiedTableName, TokenType, UpsertAction,
+    InsertStatement, InsertValues, Keyword, QualifiedTableName, TokenType, UpsertAction,
     UpsertClause, UpsertConflictTarget, UpsertUpdate,
 };
 
@@ -33,8 +33,6 @@ pub trait InsertStatementParser {
     fn parse_indexed_columns(&mut self) -> Result<Vec<IndexedColumn>, ParsingError>;
 
     fn parse_indexed_column(&mut self) -> Result<IndexedColumn, ParsingError>;
-
-    fn parse_ordering(&mut self) -> Result<Option<Ordering>, ParsingError>;
 }
 
 impl<'a> InsertStatementParser for Parser<'a> {
@@ -213,15 +211,6 @@ impl<'a> InsertStatementParser for Parser<'a> {
         let ordering = self.parse_ordering()?;
         Ok(IndexedColumn { column, ordering })
     }
-
-    fn parse_ordering(&mut self) -> Result<Option<Ordering>, ParsingError> {
-        if self.consume_as_keyword(Keyword::Asc).is_ok() {
-            return Ok(Some(Ordering::Asc));
-        } else if self.consume_as_keyword(Keyword::Desc).is_ok() {
-            return Ok(Some(Ordering::Desc));
-        }
-        Ok(None)
-    }
 }
 
 #[cfg(test)]

src/parser/mod.rs

@@ -32,7 +32,7 @@ use update::*;
 use window::*;
 
 use crate::ast::{IndexedType, LimitClause, OrderingTerm, Statement};
-use crate::{Keyword, Token, TokenType, Tokenizer};
+use crate::{Keyword, Ordering, Token, TokenType, Tokenizer};
 
 /// A parser for SQLite SQL statements
 pub struct Parser<'a> {
@@ -252,6 +252,16 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse an ordering if it exists, i.e. ASC or DESC
+    fn parse_ordering(&mut self) -> Result<Option<Ordering>, ParsingError> {
+        if self.consume_as_keyword(Keyword::Asc).is_ok() {
+            return Ok(Some(Ordering::Asc));
+        } else if self.consume_as_keyword(Keyword::Desc).is_ok() {
+            return Ok(Some(Ordering::Desc));
+        }
+        Ok(None)
+    }
+
     /// Parse an indexed type if it exists
     fn parse_indexed_type(&mut self) -> Result<Option<IndexedType>, ParsingError> {
         if self.consume_as_keyword(Keyword::Indexed).is_ok() {