rs: more IS [NOT] *

Author: donhcd

src/ast/mod.rs

@@ -161,11 +161,12 @@ pub enum Expr {
     QualifiedWildcard(Vec<Ident>),
     /// Multi-part identifier, e.g. `table_alias.column` or `schema.table.col`
     CompoundIdentifier(Vec<Ident>),
-    /// `IS NULL` expression
-    IsNull(Box<Expr>),
-    /// `IS NOT NULL` expression
-    IsNotNull(Box<Expr>),
-    /// `[ NOT ] IN (val1, val2, ...)`
+    /// `IS [NOT] { NULL | FALSE | TRUE | UNKNOWN }` expression
+    Is {
+        expr: Box<Expr>,
+        check: &'static str,
+        negated: bool,
+    },
     InList {
         expr: Box<Expr>,
         list: Vec<Expr>,
@@ -285,8 +286,17 @@ impl fmt::Display for Expr {
             Expr::Wildcard => f.write_str("*"),
             Expr::QualifiedWildcard(q) => write!(f, "{}.*", display_separated(q, ".")),
             Expr::CompoundIdentifier(s) => write!(f, "{}", display_separated(s, ".")),
-            Expr::IsNull(ast) => write!(f, "{} IS NULL", ast),
-            Expr::IsNotNull(ast) => write!(f, "{} IS NOT NULL", ast),
+            Expr::Is {
+                expr,
+                check,
+                negated,
+            } => write!(
+                f,
+                "{} IS {}{}",
+                expr,
+                if *negated { "NOT " } else { "" },
+                check
+            ),
             Expr::InList {
                 expr,
                 list,

src/parser.rs

@@ -844,13 +844,24 @@ impl<'a> Parser<'a> {
                     ))
                 }
                 Keyword::IS => {
-                    if self.parse_keyword(Keyword::NULL) {
-                        Ok((Expr::IsNull(Box::new(expr)), true))
-                    } else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
-                        Ok((Expr::IsNotNull(Box::new(expr)), true))
-                    } else {
-                        self.expected("NULL or NOT NULL after IS", self.peek_token())
-                    }
+                    let negated = self.parse_keyword(Keyword::NOT);
+                    let check = match self.next_token() {
+                        Token::Word(w) if w.keyword == Keyword::NULL => "NULL",
+                        Token::Word(w) if w.keyword == Keyword::FALSE => "FALSE",
+                        Token::Word(w) if w.keyword == Keyword::TRUE => "TRUE",
+                        Token::Word(w) if w.keyword == Keyword::UNKNOWN => "UNKNOWN",
+                        unexpected => {
+                            return self.expected("NULL, FALSE, TRUE, or UNKNOWN", unexpected)
+                        }
+                    };
+                    Ok((
+                        Expr::Is {
+                            expr: Box::new(expr),
+                            check,
+                            negated,
+                        },
+                        true,
+                    ))
                 }
                 Keyword::NOT
                 | Keyword::IN