Modify the code according to the recommendations and add more test cases

Author: wugeer

src/dialect/hive.rs

@@ -52,6 +52,7 @@ impl Dialect for HiveDialect {
         true
     }
 
+    /// See Hive <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362061#Tutorial-BuiltInOperators>
     fn supports_bang_not_operator(&self) -> bool {
         true
     }

src/parser/mod.rs

@@ -2035,13 +2035,6 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse_bang_not(&mut self) -> Result<Expr, ParserError> {
-        Ok(Expr::UnaryOp {
-            op: UnaryOperator::BangNot,
-            expr: Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::UnaryNot))?),
-        })
-    }
-
     /// Parses fulltext expressions [`sqlparser::ast::Expr::MatchAgainst`]
     ///
     /// # Errors
@@ -2813,40 +2806,32 @@ impl<'a> Parser<'a> {
                 data_type: self.parse_data_type()?,
                 format: None,
             })
-        } else if Token::ExclamationMark == tok {
-            if self.dialect.supports_factorial_operator() {
-                match expr {
-                    Expr::Value(_) | Expr::Identifier(_) | Expr::Nested(_) | Expr::BinaryOp{..} => Ok(Expr::UnaryOp {
-                        op: UnaryOperator::PGPostfixFactorial,
-                        expr: Box::new(expr),
-                    }),
-                    _ => {
-                        self.expected(
-                            "Value or Identifier or  Nested or BinaryOp struct before factorial operator(!)", self.peek_token())
-                    },
-                }
-            } else if self.dialect.supports_bang_not_operator() {
-                let token = self.next_token();
-                match token.token {
-                    Token::Word(_) | Token::Number(..) => Ok(Expr::UnaryOp {
+        } else if Token::ExclamationMark == tok && self.dialect.supports_factorial_operator() {
+            Ok(Expr::UnaryOp {
+                op: UnaryOperator::PGPostfixFactorial,
+                expr: Box::new(expr),
+            })
+        } else if Token::ExclamationMark == tok && self.dialect.supports_bang_not_operator() {
+            let token = self.next_token();
+            match token.token {
+                Token::Word(_) | Token::Number(..)
+                    if !matches!(
+                        expr,
+                        Expr::Value(_)
+                            | Expr::Identifier(_)
+                            | Expr::Nested(_)
+                            | Expr::BinaryOp { .. }
+                    ) =>
+                {
+                    Ok(Expr::UnaryOp {
                         op: UnaryOperator::BangNot,
                         expr: Box::new(expr),
-                    }),
-                    _ => {
-                        parser_err!(
-                            "current dialect support bang not operator, but with wrong synx",
-                            tok.location
-                        )
-                    }
+                    })
                 }
-            } else {
-                parser_err!(
-                    format!(
-                        "current dialect: {:?} does not support factorial operator or bang not operator",
-                        self.dialect
-                    ),
-                    self.peek_token().location
-                )
+                _ => parser_err!(
+                    "current dialect support bang not operator, but with wrong syntax",
+                    tok.location
+                ),
             }
         } else if Token::LBracket == tok {
             if dialect_of!(self is PostgreSqlDialect | DuckDbDialect | GenericDialect) {

tests/sqlparser_common.rs

@@ -11490,19 +11490,24 @@ fn parse_bang_not() {
         )
     }
 
-    let sql = "SELECT a!";
-    assert_eq!(
-        dialects.parse_sql_statements(sql).unwrap_err(),
-        ParserError::ParserError(
-            "current dialect support bang not operator, but with wrong synx".to_string()
-        )
-    );
+    let sql_statements = ["SELECT a!", "SELECT a ! b", "SELECT a ! as b"];
 
-    let sql = "SELECT !a";
-    assert_eq!(
-        all_dialects_where(|d| !d.supports_bang_not_operator())
-            .parse_sql_statements(sql)
-            .unwrap_err(),
-        ParserError::ParserError("Expected: an expression, found: !".to_string())
-    );
+    for &sql in &sql_statements {
+        assert_eq!(
+            dialects.parse_sql_statements(sql).unwrap_err(),
+            ParserError::ParserError(
+                "current dialect support bang not operator, but with wrong syntax".to_string()
+            )
+        );
+    }
+
+    let sql_statements = ["SELECT !a", "SELECT !a b", "SELECT !a as b"];
+    let dialects = all_dialects_where(|d| !d.supports_bang_not_operator());
+
+    for &sql in &sql_statements {
+        assert_eq!(
+            dialects.parse_sql_statements(sql).unwrap_err(),
+            ParserError::ParserError("Expected: an expression, found: !".to_string())
+        );
+    }
 }