sql_parser: parser error fmt and refactoring

Author: Almaz-KG

src/ast/create.rs

@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use crate::ParsingError;
+use crate::parser::errors::ParsingError;
 
 use super::{
     ColumnDefinition, ConflictClause, DeleteStatement, Expression, ForeignKeyClause, Identifier,

src/ast/expression.rs

@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use crate::{ParsingError, TokenType};
+use crate::{errors::ParsingError, TokenType};
 
 use super::{OrderingTerm, SelectStatement};
 

src/parser/alter/mod.rs

@@ -1,8 +1,7 @@
-use crate::{AlterTableStatement, AlterTableStatementType, Identifier, Keyword};
-
-use super::{
-    column_definition::ColumnDefinitionParser, expression::IdentifierParser, Parser, ParsingError,
-};
+use crate::column::ColumnDefinitionParser;
+use crate::expression::IdentifierParser;
+use crate::parser::errors::ParsingError;
+use crate::{AlterTableStatement, AlterTableStatementType, Identifier, Keyword, Parser};
 
 pub trait AlterTableStatementParser {
     fn parse_alter_table_statement(&mut self) -> Result<AlterTableStatement, ParsingError>;

src/parser/column_definition.rs src/parser/column/mod.rs

@@ -1,7 +1,8 @@
+use crate::parser::errors::ParsingError;
 use crate::{
     expression::IdentifierParser,
     parser::{insert::InsertStatementParser, select::SelectStatementParser},
-    CreateIndexStatement, Keyword, Parser, ParsingError,
+    CreateIndexStatement, Keyword, Parser,
 };
 
 use super::CreateStatementParser;

src/parser/create/create_index.rs

@@ -1,11 +1,11 @@
+use crate::parser::errors::ParsingError;
 use crate::parser::{
-    column_definition::ColumnDefinitionParser, insert::InsertStatementParser,
-    select::SelectStatementParser,
+    column::ColumnDefinitionParser, insert::InsertStatementParser, select::SelectStatementParser,
 };
 use crate::{
     expression::{ExpressionParser, IdentifierParser},
     ColumnDefinition, CreateTableColumnDef, CreateTableOption, CreateTableStatement, Keyword,
-    Parser, ParsingError, TableConstraint, TableConstraintType, TableOption, TokenType,
+    Parser, TableConstraint, TableConstraintType, TableOption, TokenType,
 };
 
 use super::CreateStatementParser;

src/parser/create/create_table.rs

@@ -1,11 +1,11 @@
+use super::CreateStatementParser;
+use crate::expression::{ExpressionParser, IdentifierParser};
+use crate::parser::errors::ParsingError;
 use crate::{
-    expression::{ExpressionParser, IdentifierParser},
-    CreateTriggerStatement, Expression, Keyword, Parser, ParsingError, TokenType, TriggerEvent,
-    TriggerEventType, TriggerPreCondition, TriggerStatement,
+    CreateTriggerStatement, Expression, Keyword, Parser, TokenType, TriggerEvent, TriggerEventType,
+    TriggerPreCondition, TriggerStatement,
 };
 
-use super::CreateStatementParser;
-
 pub trait CreateTriggerStatementParser {
     fn parse_create_trigger_statement(
         &mut self,

src/parser/create/create_trigger.rs

@@ -1,11 +1,11 @@
+use super::CreateStatementParser;
+use crate::expression::IdentifierParser;
+use crate::parser::errors::ParsingError;
 use crate::{
-    expression::IdentifierParser,
     parser::{insert::InsertStatementParser, select::SelectStatementParser},
-    CreateViewStatement, Keyword, Parser, ParsingError,
+    CreateViewStatement, Keyword, Parser,
 };
 
-use super::CreateStatementParser;
-
 pub trait CreateViewStatementParser {
     fn parse_create_view_statement(
         &mut self,

src/parser/create/create_view.rs

@@ -1,9 +1,7 @@
-use crate::{
-    expression::{ExpressionParser, IdentifierParser},
-    CreateVirtualTableStatement, Expression, Keyword, Parser, ParsingError, TokenType,
-};
-
 use super::CreateStatementParser;
+use crate::expression::{ExpressionParser, IdentifierParser};
+use crate::parser::errors::ParsingError;
+use crate::{CreateVirtualTableStatement, Expression, Keyword, Parser, TokenType};
 
 pub trait CreateVirtualTableStatementParser {
     fn parse_create_virtual_table_statement(

src/parser/create/create_virtual_table.rs

@@ -1,4 +1,5 @@
-use crate::{expression::IdentifierParser, Identifier, Keyword, Parser, ParsingError};
+use crate::parser::errors::ParsingError;
+use crate::{expression::IdentifierParser, Identifier, Keyword, Parser};
 
 pub trait DropGenericStatementParser {
     fn parse_drop_statement_generic(&mut self) -> Result<(bool, Identifier), ParsingError>;

src/parser/drop/drop_generic.rs

@@ -1,6 +1,6 @@
-use crate::{DropIndexStatement, Keyword, Parser, ParsingError, Statement};
-
 use super::DropGenericStatementParser;
+use crate::parser::errors::ParsingError;
+use crate::{DropIndexStatement, Keyword, Parser, Statement};
 
 pub trait DropIndexStatementParser {
     fn parse_drop_index_statement(&mut self) -> Result<Statement, ParsingError>;
@@ -34,8 +34,9 @@ pub mod test_utils {
 #[cfg(test)]
 mod drop_index_tests {
     use crate::ast::DropIndexStatement;
+    use crate::parser::errors::ParsingError;
     use crate::parser::test_utils::{run_rainy_day_test, run_sunny_day_test};
-    use crate::{Identifier, Parser, ParsingError, Statement};
+    use crate::{Identifier, Parser, Statement};
 
     #[test]
     fn test_drop_index_valid() {

src/parser/drop/drop_index.rs

@@ -1,4 +1,5 @@
-use crate::{DropTableStatement, Keyword, Parser, ParsingError, Statement};
+use crate::parser::errors::ParsingError;
+use crate::{DropTableStatement, Keyword, Parser, Statement};
 
 use super::DropGenericStatementParser;
 
@@ -34,8 +35,9 @@ pub mod test_utils {
 #[cfg(test)]
 mod drop_table_tests {
     use crate::ast::DropTableStatement;
+    use crate::parser::errors::ParsingError;
     use crate::parser::test_utils::{run_rainy_day_test, run_sunny_day_test};
-    use crate::{Identifier, Parser, ParsingError, Statement};
+    use crate::{Identifier, Parser, Statement};
 
     #[test]
     fn test_drop_table_valid() {

src/parser/drop/drop_table.rs

@@ -1,6 +1,6 @@
-use crate::{DropTriggerStatement, Keyword, Parser, ParsingError, Statement};
-
 use super::DropGenericStatementParser;
+use crate::parser::errors::ParsingError;
+use crate::{DropTriggerStatement, Keyword, Parser, Statement};
 
 pub trait DropTriggerStatementParser {
     fn parse_drop_trigger_statement(&mut self) -> Result<Statement, ParsingError>;
@@ -34,8 +34,9 @@ pub mod test_utils {
 #[cfg(test)]
 mod drop_trigger_tests {
     use crate::ast::DropTriggerStatement;
+    use crate::parser::errors::ParsingError;
     use crate::parser::test_utils::{run_rainy_day_test, run_sunny_day_test};
-    use crate::{Identifier, Parser, ParsingError, Statement};
+    use crate::{Identifier, Parser, Statement};
 
     #[test]
     fn test_drop_trigger_valid() {

src/parser/drop/drop_trigger.rs

@@ -1,4 +1,5 @@
-use crate::{DropViewStatement, Keyword, Parser, ParsingError, Statement};
+use crate::parser::errors::ParsingError;
+use crate::{DropViewStatement, Keyword, Parser, Statement};
 
 use super::DropGenericStatementParser;
 
@@ -34,8 +35,9 @@ pub mod test_utils {
 #[cfg(test)]
 mod drop_view_tests {
     use crate::ast::DropViewStatement;
+    use crate::parser::errors::ParsingError;
     use crate::parser::test_utils::{run_rainy_day_test, run_sunny_day_test};
-    use crate::{Identifier, Parser, ParsingError, Statement};
+    use crate::{Identifier, Parser, Statement};
 
     #[test]
     fn test_drop_view_valid() {

src/parser/drop/drop_view.rs

@@ -10,7 +10,8 @@ use drop_table::*;
 use drop_trigger::*;
 use drop_view::*;
 
-use crate::{Keyword, Parser, ParsingError, Statement};
+use crate::parser::errors::ParsingError;
+use crate::{Keyword, Parser, Statement};
 
 pub trait DropStatementParser {
     fn parse_drop_statement(&mut self) -> Result<Statement, ParsingError>;

src/parser/drop/mod.rs

@@ -1,6 +1,5 @@
-use crate::{
-    BetweenExpression, BinaryMatchingExpression, Expression, Keyword, Parser, ParsingError,
-};
+use crate::parser::errors::ParsingError;
+use crate::{BetweenExpression, BinaryMatchingExpression, Expression, Keyword, Parser};
 
 use super::ExpressionParser;
 

src/parser/expression/between_expr.rs

@@ -1,4 +1,5 @@
-use crate::{CaseExpression, Expression, Keyword, Parser, ParsingError, WhenExpression};
+use crate::parser::errors::ParsingError;
+use crate::{CaseExpression, Expression, Keyword, Parser, WhenExpression};
 
 use super::ExpressionParser;
 

src/parser/expression/case_expr.rs

@@ -1,4 +1,5 @@
-use crate::{Expression, Keyword, Parser, ParsingError, TokenType};
+use crate::parser::errors::ParsingError;
+use crate::{Expression, Keyword, Parser, TokenType};
 
 use super::{data_type::DataTypeParser, ExpressionParser};
 

src/parser/expression/cast_expr.rs

@@ -1,4 +1,5 @@
-use crate::{CollateExpressionStatement, Expression, Keyword, Parser, ParsingError};
+use crate::parser::errors::ParsingError;
+use crate::{CollateExpressionStatement, Expression, Keyword, Parser};
 
 pub trait CollateExpressionParser {
     /// Parse a COLLATE expression, i.e. an expression followed by the COLLATE keyword and a string literal

src/parser/expression/collate_expr.rs

@@ -1,6 +1,7 @@
 use crate::{DataType, TokenType};
 
-use super::{Parser, ParsingError};
+use super::Parser;
+use crate::parser::errors::ParsingError;
 
 /// Trait for parsing a [DataType](https://www.sqlite.org/syntax/type-name.html)
 pub trait DataTypeParser {

src/parser/expression/data_type.rs

@@ -1,5 +1,6 @@
+use crate::parser::errors::ParsingError;
 use crate::parser::select::SelectStatementParser;
-use crate::{ExistsStatement, Expression, Keyword, Parser, ParsingError, TokenType};
+use crate::{ExistsStatement, Expression, Keyword, Parser, TokenType};
 
 pub trait ExistsExpressionParser {
     fn parse_exists_expression(&mut self, is_not: bool) -> Result<Expression, ParsingError>;

src/parser/expression/exists_expr.rs

@@ -1,6 +1,7 @@
+use crate::parser::errors::ParsingError;
 use crate::{
-    parser::window_definition::WindowDefinitionParser, Expression, Function, FunctionArg,
-    FunctionArgType, Identifier, Keyword, OverClause, Parser, ParsingError, TokenType,
+    parser::window::WindowDefinitionParser, Expression, Function, FunctionArg, FunctionArgType,
+    Identifier, Keyword, OverClause, Parser, TokenType,
 };
 
 use super::ExpressionParser;

src/parser/expression/function_expr.rs

@@ -1,4 +1,5 @@
-use crate::{Identifier, Parser, ParsingError, TokenType};
+use crate::parser::errors::ParsingError;
+use crate::{Identifier, Parser, TokenType};
 
 pub trait IdentifierParser {
     /// Parse an identifier

src/parser/expression/identifier.rs

@@ -1,6 +1,7 @@
+use crate::parser::errors::ParsingError;
 use crate::{
     parser::select::SelectStatementParser, BinaryMatchingExpression, Expression, Identifier,
-    InExpression, Keyword, Parser, ParsingError, TokenType,
+    InExpression, Keyword, Parser, TokenType,
 };
 
 use super::ExpressionParser;

src/parser/expression/in_expr.rs

@@ -1,4 +1,5 @@
-use crate::{AnIsExpression, BinaryMatchingExpression, Expression, Keyword, Parser, ParsingError};
+use crate::parser::errors::ParsingError;
+use crate::{AnIsExpression, BinaryMatchingExpression, Expression, Keyword, Parser};
 
 use super::ExpressionParser;
 

src/parser/expression/is_expr.rs

@@ -1,6 +1,6 @@
+use crate::parser::errors::ParsingError;
 use crate::{
     BinaryMatchingExpression, EscapeExpression, Expression, Keyword, LikeExpressionType, Parser,
-    ParsingError,
 };
 
 use super::ExpressionParser;

src/parser/expression/like_expr.rs

@@ -12,9 +12,10 @@ mod like_expr;
 mod raise_expr;
 mod regexp_match_expr;
 
+use crate::parser::errors::ParsingError;
 use crate::{
-    BinaryOp, Expression, Keyword, LiteralValue, Parser, ParsingError, TokenType,
-    UnaryMatchingExpression, UnaryOp,
+    BinaryOp, Expression, Keyword, LiteralValue, Parser, TokenType, UnaryMatchingExpression,
+    UnaryOp,
 };
 use between_expr::BetweenExpressionParser;
 use case_expr::CaseExpressionParser;

src/parser/expression/mod.rs

@@ -1,4 +1,5 @@
-use crate::{Expression, Keyword, Parser, ParsingError, RaiseFunction, TokenType};
+use crate::parser::errors::ParsingError;
+use crate::{Expression, Keyword, Parser, RaiseFunction, TokenType};
 
 pub trait RaiseExpressionParser {
     fn parse_raise_expression(&mut self) -> Result<Expression, ParsingError>;
@@ -58,7 +59,8 @@ impl<'a> RaiseExpressionParser for Parser<'a> {
 
 #[cfg(test)]
 mod raise_expression_tests {
-    use crate::{parser::test_utils::run_rainy_day_test, ParsingError, RaiseFunction};
+    use crate::parser::ParsingError;
+    use crate::{parser::test_utils::run_rainy_day_test, RaiseFunction};
 
     use crate::expression::test_utils::*;
 

src/parser/expression/raise_expr.rs

@@ -1,4 +1,5 @@
-use crate::{BinaryMatchingExpression, Expression, Keyword, Parser, ParsingError};
+use crate::parser::errors::ParsingError;
+use crate::{BinaryMatchingExpression, Expression, Keyword, Parser};
 
 use super::ExpressionParser;
 

src/parser/expression/regexp_match_expr.rs

@@ -1,7 +1,7 @@
 use std::iter::Peekable;
 
 pub mod alter;
-pub mod column_definition;
+pub mod column;
 pub mod create;
 pub mod cte;
 pub mod delete;
@@ -14,10 +14,7 @@ pub mod select;
 pub mod sqlite;
 pub mod trx;
 pub mod update;
-pub mod window_definition;
-
-#[cfg(test)]
-mod test_utils;
+pub mod window;
 
 use crate::{
     IndexedType, Keyword, LimitClause, OrderingTerm, SelectStatement, Statement, Token, TokenType,
@@ -28,15 +25,18 @@ use create::*;
 use cte::CteStatementParser;
 use delete::DeleteStatementParser;
 use drop::DropStatementParser;
-pub use errors::*;
+use errors::*;
 use explain::ExplainStatementParser;
 use expression::ExpressionParser;
 use insert::InsertStatementParser;
 use select::{SelectStatementParser, ValuesStatementParser};
 use sqlite::SQLite3StatementParser;
 use trx::TransactionStatementParser;
 use update::UpdateStatementParser;
-use window_definition::WindowDefinitionParser;
+use window::WindowDefinitionParser;
+
+#[cfg(test)]
+mod test_utils;
 
 /// A parser for SQLite SQL statements
 pub struct Parser<'a> {

src/parser/mod.rs

@@ -8,9 +8,10 @@ use crate::{
 };
 
 use super::expression::ExpressionParser;
-use super::window_definition::WindowDefinitionParser;
-use super::{Parser, ParsingError};
+use super::window::WindowDefinitionParser;
+use super::Parser;
 use crate::ast::{Select, SelectItem, SelectStatement};
+use crate::parser::errors::ParsingError;
 pub use values::ValuesStatementParser;
 
 /// Trait for parsing SELECT statements
@@ -592,13 +593,12 @@ pub mod test_utils {
 #[cfg(test)]
 mod test_select_result_columns {
     use crate::{
-        BinaryOp, DistinctType, Expression, Identifier, ParsingError, SelectItem, SelectStatement,
-        Statement,
+        BinaryOp, DistinctType, Expression, Identifier, SelectItem, SelectStatement, Statement,
     };
 
     use super::test_utils::*;
     use crate::parser::expression::test_utils::*;
-    use crate::parser::test_utils::*;
+    use crate::parser::{test_utils::*, ParsingError};
 
     #[test]
     fn test_select_distinct() {

src/parser/select/mod.rs

@@ -1,6 +1,6 @@
+use crate::parser::errors::ParsingError;
 use crate::{
-    expression::ExpressionParser, Expression, Keyword, Parser, ParsingError, TokenType,
-    ValuesStatement,
+    expression::ExpressionParser, Expression, Keyword, Parser, TokenType, ValuesStatement,
 };
 
 pub trait ValuesStatementParser {