sql-parser: clean-up of dbg! macros

Author: Almaz-KG

src/parser/expression/function_expr.rs

@@ -268,9 +268,6 @@ impl<'a> FunctionParser for Parser<'a> {
             }
         };
 
-        dbg!(&frame_type);
-        dbg!(&self.peek_token());
-
         // consume the frame type token
         self.consume_token()?;
 

src/parser/expression/identifier.rs

@@ -24,14 +24,12 @@ impl<'a> IdentifierParser for Parser<'a> {
             }
         }
 
-        dbg!("Expected next identifier: {}", expected_next_identifier);
         if expected_next_identifier {
             return Err(ParsingError::UnexpectedToken(
                 "Expected identifier".to_string(),
             ));
         }
 
-        dbg!("Parsed components: {:?}", &components);
         match components.len() {
             0 => Err(ParsingError::UnexpectedToken(
                 "Expected identifier".to_string(),
@@ -45,7 +43,6 @@ impl<'a> IdentifierParser for Parser<'a> {
             }
             2 => {
                 if components[1] == "*" {
-                    dbg!("Parsed table name with wildcard {}", &components[0]);
                     Ok(Identifier::NameWithWildcard(components[0].to_string()))
                 } else {
                     Ok(Identifier::Compound(components))

src/parser/expression/mod.rs

@@ -95,7 +95,6 @@ pub trait ExpressionParser {
 impl<'a> ExpressionParser for Parser<'a> {
     /// Parse an SQLite3 [expr](https://www.sqlite.org/lang_expr.html#the_expr_list)
     fn parse_expression(&mut self) -> Result<Expression, ParsingError> {
-        dbg!("Parsing expression");
         // Check if it's one of the special expressions
         if let Ok(keyword) = self.peek_as_keyword() {
             match keyword {
@@ -220,7 +219,6 @@ impl<'a> ExpressionParser for Parser<'a> {
             }
         }
 
-        dbg!("Parsed expression: {:?}", &expression);
         Ok(expression)
     }
 

src/parser/select/mod.rs

@@ -45,7 +45,6 @@ impl<'a> SelectStatementParser for Parser<'a> {
     }
 
     fn parse_select_columns(&mut self) -> Result<Vec<SelectItem>, ParsingError> {
-        dbg!("Parsing select columns");
         let mut select_items = Vec::new();
 
         loop {
@@ -56,24 +55,17 @@ impl<'a> SelectStatementParser for Parser<'a> {
                 break;
             }
         }
-
-        dbg!("Parsed select columns");
-        dbg!(&select_items);
         Ok(select_items)
     }
 
     fn parse_select_column(&mut self) -> Result<SelectItem, ParsingError> {
-        dbg!("Parsing select column");
         if self.consume_as(TokenType::Star).is_ok() {
             return Ok(SelectItem::Expression(Expression::Identifier(
                 Identifier::Wildcard,
             )));
         }
 
-        dbg!("Parsing select column as expression");
         if let Ok(expression) = self.parse_expression() {
-            dbg!("Parsed select column as expression, {:?}", &expression);
-
             // Consume the AS keyword if it exists
             let _ = self.consume_as_keyword(Keyword::As);
             if let Ok(alias) = self.consume_as_id() {
@@ -83,10 +75,7 @@ impl<'a> SelectStatementParser for Parser<'a> {
             return Ok(SelectItem::Expression(expression));
         }
 
-        dbg!("Parsing select column as table name with wildcard");
         if let Ok(table_name) = self.peek_as_string() {
-            dbg!("Parsing select column as table name with wildcard");
-            dbg!(&table_name);
             self.consume_token()?;
             self.consume_as(TokenType::Dot)?;
             self.consume_as(TokenType::Star)?;

src/parser/sqlite/vacuum.rs

@@ -37,7 +37,6 @@ impl<'a> VacuumStatementParser for Parser<'a> {
                 file_name: None,
             }
         };
-        dbg!(&self.peek_token()?);
         self.finalize_statement_parsing()?;
         Ok(Statement::Vacuum(vacuum_statement))
     }