add more consistency in ast (#523)

* add more consistency in ast

* refactor styling

src/ast/mod.rs

@@ -337,9 +337,9 @@ pub enum Expr {
         results: Vec<Expr>,
         else_result: Option<Box<Expr>>,
     },
-    /// An exists expression `EXISTS(SELECT ...)`, used in expressions like
+    /// An exists expression `[ NOT ] EXISTS(SELECT ...)`, used in expressions like
-    /// `WHERE EXISTS (SELECT ...)`.
+    /// `WHERE [ NOT ] EXISTS (SELECT ...)`.
-    Exists(Box<Query>),
+    Exists { subquery: Box<Query>, negated: bool },
     /// A parenthesized subquery `(SELECT ...)`, used in expression like
     /// `SELECT (subquery) AS x` or `WHERE (subquery) = x`
     Subquery(Box<Query>),
@@ -466,7 +466,12 @@ impl fmt::Display for Expr {
                 }
                 write!(f, " END")
             }
-            Expr::Exists(s) => write!(f, "EXISTS ({})", s),
+            Expr::Exists { subquery, negated } => write!(
+                f,
+                "{}EXISTS ({})",
+                if *negated { "NOT " } else { "" },
+                subquery
+            ),
             Expr::Subquery(s) => write!(f, "({})", s),
             Expr::ListAgg(listagg) => write!(f, "{}", listagg),
             Expr::GroupingSets(sets) => {

src/parser.rs

@@ -426,7 +426,7 @@ impl<'a> Parser<'a> {
                 Keyword::CASE => self.parse_case_expr(),
                 Keyword::CAST => self.parse_cast_expr(),
                 Keyword::TRY_CAST => self.parse_try_cast_expr(),
-                Keyword::EXISTS => self.parse_exists_expr(),
+                Keyword::EXISTS => self.parse_exists_expr(false),
                 Keyword::EXTRACT => self.parse_extract_expr(),
                 Keyword::POSITION => self.parse_position_expr(),
                 Keyword::SUBSTRING => self.parse_substring_expr(),
@@ -438,10 +438,7 @@ impl<'a> Parser<'a> {
                     self.expect_token(&Token::LBracket)?;
                     self.parse_array_expr(true)
                 }
-                Keyword::NOT => Ok(Expr::UnaryOp {
+                Keyword::NOT => self.parse_not(),
-                    op: UnaryOperator::Not,
-                    expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
-                }),
                 // Here `w` is a word, check if it's a part of a multi-part
                 // identifier, a function call, or a simple identifier:
                 _ => match self.peek_token() {
@@ -783,9 +780,12 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse a SQL EXISTS expression e.g. `WHERE EXISTS(SELECT ...)`.
-    pub fn parse_exists_expr(&mut self) -> Result<Expr, ParserError> {
+    pub fn parse_exists_expr(&mut self, negated: bool) -> Result<Expr, ParserError> {
         self.expect_token(&Token::LParen)?;
-        let exists_node = Expr::Exists(Box::new(self.parse_query()?));
+        let exists_node = Expr::Exists {
+            negated,
+            subquery: Box::new(self.parse_query()?),
+        };
         self.expect_token(&Token::RParen)?;
         Ok(exists_node)
     }
@@ -984,6 +984,26 @@ impl<'a> Parser<'a> {
         }
     }
 
+    pub fn parse_not(&mut self) -> Result<Expr, ParserError> {
+        match self.peek_token() {
+            Token::Word(w) => match w.keyword {
+                Keyword::EXISTS => {
+                    let negated = true;
+                    let _ = self.parse_keyword(Keyword::EXISTS);
+                    self.parse_exists_expr(negated)
+                }
+                _ => Ok(Expr::UnaryOp {
+                    op: UnaryOperator::Not,
+                    expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
+                }),
+            },
+            _ => Ok(Expr::UnaryOp {
+                op: UnaryOperator::Not,
+                expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
+            }),
+        }
+    }
+
     /// Parse an INTERVAL literal.
     ///
     /// Some syntactically valid intervals:

tests/sqlparser_common.rs

@@ -3625,16 +3625,19 @@ fn parse_exists_subquery() {
     let sql = "SELECT * FROM t WHERE EXISTS (SELECT 1)";
     let select = verified_only_select(sql);
     assert_eq!(
-        Expr::Exists(Box::new(expected_inner.clone())),
+        Expr::Exists {
+            negated: false,
+            subquery: Box::new(expected_inner.clone())
+        },
         select.selection.unwrap(),
     );
 
     let sql = "SELECT * FROM t WHERE NOT EXISTS (SELECT 1)";
     let select = verified_only_select(sql);
     assert_eq!(
-        Expr::UnaryOp {
+        Expr::Exists {
-            op: UnaryOperator::Not,
+            negated: true,
-            expr: Box::new(Expr::Exists(Box::new(expected_inner))),
+            subquery: Box::new(expected_inner)
         },
         select.selection.unwrap(),
     );