fixup: make NOTNULL/NOT NULL an alias for Expr::IsNotNull

Author: ryanschneider

src/ast/mod.rs

@@ -778,12 +778,6 @@ pub enum Expr {
     IsNull(Box<Expr>),
     /// `IS NOT NULL` operator
     IsNotNull(Box<Expr>),
-    /// `NOTNULL` or `NOT NULL` operator
-    NotNull {
-        expr: Box<Expr>,
-        /// true if `NOT NULL`, false if `NOTNULL`
-        with_space: bool,
-    },
     /// `IS UNKNOWN` operator
     IsUnknown(Box<Expr>),
     /// `IS NOT UNKNOWN` operator
@@ -1458,12 +1452,6 @@ impl fmt::Display for Expr {
             Expr::IsNotFalse(ast) => write!(f, "{ast} IS NOT FALSE"),
             Expr::IsNull(ast) => write!(f, "{ast} IS NULL"),
             Expr::IsNotNull(ast) => write!(f, "{ast} IS NOT NULL"),
-            Expr::NotNull { expr, with_space } => write!(
-                f,
-                "{} {}",
-                expr,
-                if *with_space { "NOT NULL" } else { "NOTNULL" }
-            ),
             Expr::IsUnknown(ast) => write!(f, "{ast} IS UNKNOWN"),
             Expr::IsNotUnknown(ast) => write!(f, "{ast} IS NOT UNKNOWN"),
             Expr::InList {

src/ast/spans.rs

@@ -1437,7 +1437,6 @@ impl Spanned for Expr {
             Expr::IsNotTrue(expr) => expr.span(),
             Expr::IsNull(expr) => expr.span(),
             Expr::IsNotNull(expr) => expr.span(),
-            Expr::NotNull { expr, .. } => expr.span(),
             Expr::IsUnknown(expr) => expr.span(),
             Expr::IsNotUnknown(expr) => expr.span(),
             Expr::IsDistinctFrom(lhs, rhs) => lhs.span().union(&rhs.span()),

src/parser/mod.rs

@@ -3574,10 +3574,7 @@ impl<'a> Parser<'a> {
                             regexp,
                         })
                     } else if dialect.supports_is_not_null_alias(NotSpaceNull) && negated && null {
-                        Ok(Expr::NotNull {
-                            expr: Box::new(expr),
-                            with_space: true,
-                        })
+                        Ok(Expr::IsNotNull(Box::new(expr)))
                     } else if self.parse_keyword(Keyword::IN) {
                         self.parse_in(expr, negated)
                     } else if self.parse_keyword(Keyword::BETWEEN) {
@@ -3616,10 +3613,7 @@ impl<'a> Parser<'a> {
                     }
                 }
                 Keyword::NOTNULL if dialect.supports_is_not_null_alias(NotNull) => {
-                    Ok(Expr::NotNull {
-                        expr: Box::new(expr),
-                        with_space: false,
-                    })
+                    Ok(Expr::IsNotNull(Box::new(expr)))
                 }
                 Keyword::MEMBER => {
                     if self.parse_keyword(Keyword::OF) {

tests/sqlparser_common.rs

@@ -16005,11 +16005,12 @@ fn parse_not_null_unsupported() {
 
 #[test]
 fn parse_not_null_supported() {
-    // DuckDB and SQLite support `x NOT NULL` as an expression
+    // DuckDB and SQLite support `x NOT NULL` as an alias for `x IS NOT NULL`
     let sql = r#"WITH t AS (SELECT NULL AS x) SELECT x NOT NULL FROM t"#;
+    let canonical = r#"WITH t AS (SELECT NULL AS x) SELECT x IS NOT NULL FROM t"#;
     let dialects =
         all_dialects_where(|d| d.supports_is_not_null_alias(IsNotNullAlias::NotSpaceNull));
-    let stmt = dialects.one_statement_parses_to(sql, sql);
+    let stmt = dialects.one_statement_parses_to(sql, canonical);
     match stmt {
         Statement::Query(qry) => match *qry.body {
             SetExpr::Select(select) => {
@@ -16022,14 +16023,11 @@ fn parse_not_null_supported() {
                         };
                         assert_eq!(
                             *expr,
-                            Expr::NotNull {
-                                expr: Box::new(Identifier(Ident {
-                                    value: "x".to_string(),
-                                    quote_style: None,
-                                    span: fake_span,
-                                })),
-                                with_space: true,
-                            },
+                            Expr::IsNotNull(Box::new(Identifier(Ident {
+                                value: "x".to_string(),
+                                quote_style: None,
+                                span: fake_span,
+                            })),),
                         );
                     }
                     _ => unreachable!(),
@@ -16088,10 +16086,11 @@ fn parse_notnull_unsupported() {
 
 #[test]
 fn parse_notnull_supported() {
-    // DuckDB and SQLite support `x NOT NULL` as an expression
+    // Postgres, DuckDB and SQLite support `x NOTNULL` as an alias for `x IS NOT NULL`
     let sql = r#"WITH t AS (SELECT NULL AS x) SELECT x NOTNULL FROM t"#;
+    let canonical = r#"WITH t AS (SELECT NULL AS x) SELECT x IS NOT NULL FROM t"#;
     let dialects = all_dialects_where(|d| d.supports_is_not_null_alias(IsNotNullAlias::NotNull));
-    let stmt = dialects.one_statement_parses_to(sql, "");
+    let stmt = dialects.one_statement_parses_to(sql, canonical);
     match stmt {
         Statement::Query(qry) => match *qry.body {
             SetExpr::Select(select) => {
@@ -16104,14 +16103,11 @@ fn parse_notnull_supported() {
                         };
                         assert_eq!(
                             *expr,
-                            Expr::NotNull {
-                                expr: Box::new(Identifier(Ident {
-                                    value: "x".to_string(),
-                                    quote_style: None,
-                                    span: fake_span,
-                                })),
-                                with_space: false,
-                            },
+                            Expr::IsNotNull(Box::new(Identifier(Ident {
+                                value: "x".to_string(),
+                                quote_style: None,
+                                span: fake_span,
+                            })),),
                         );
                     }
                     _ => unreachable!(),