fixup: change to supports_is_not_null_alias(IsNotNullAlias)

ryanschneider · ryanschneider · commit f022dfaa9a15 · 2025-07-07T13:51:17.000-07:00
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -759,8 +759,8 @@ pub enum Expr {
     /// `NOTNULL` or `NOT NULL` operator
     NotNull {
         expr: Box<Expr>,
-        /// true if `NOTNULL`, false if `NOT NULL`
-        one_word: bool,
+        /// true if `NOT NULL`, false if `NOTNULL`
+        with_space: bool,
     },
     /// `IS UNKNOWN` operator
     IsUnknown(Box<Expr>),
@@ -1436,11 +1436,11 @@ 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, one_word } => write!(
+            Expr::NotNull { expr, with_space } => write!(
                 f,
                 "{} {}",
                 expr,
-                if *one_word { "NOTNULL" } else { "NOT NULL" }
+                if *with_space { "NOT NULL" } else { "NOTNULL" }
             ),
             Expr::IsUnknown(ast) => write!(f, "{ast} IS UNKNOWN"),
             Expr::IsNotUnknown(ast) => write!(f, "{ast} IS NOT UNKNOWN"),
diff --git a/src/dialect/duckdb.rs b/src/dialect/duckdb.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::dialect::Dialect;
+use crate::dialect::{Dialect, IsNotNullAlias};
 
 /// A [`Dialect`] for [DuckDB](https://duckdb.org/)
 #[derive(Debug, Default)]
@@ -95,11 +95,12 @@ impl Dialect for DuckDbDialect {
         true
     }
 
-    fn supports_not_null(&self) -> bool {
-        true
-    }
-
-    fn supports_notnull(&self) -> bool {
-        true
+    /// DuckDB supports `NOT NULL` and `NOTNULL` as aliases
+    /// for `IS NOT NULL`, see DuckDB Comparisons <https://duckdb.org/docs/stable/sql/expressions/comparison_operators#between-and-is-not-null>
+    fn supports_is_not_null_alias(&self, alias: IsNotNullAlias) -> bool {
+        match alias {
+            IsNotNullAlias::NotNull => true,
+            IsNotNullAlias::NotSpaceNull => true,
+        }
     }
 }
diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs
@@ -55,6 +55,7 @@ use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
 use crate::tokenizer::Token;
 
+use crate::dialect::IsNotNullAlias::{NotNull, NotSpaceNull};
 #[cfg(not(feature = "std"))]
 use alloc::boxed::Box;
 
@@ -650,12 +651,17 @@ pub trait Dialect: Debug + Any {
                 Token::Word(w) if w.keyword == Keyword::MATCH => Ok(p!(Like)),
                 Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(p!(Like)),
                 Token::Word(w) if w.keyword == Keyword::MEMBER => Ok(p!(Like)),
-                Token::Word(w) if w.keyword == Keyword::NULL && self.supports_not_null() => {
+                Token::Word(w)
+                    if w.keyword == Keyword::NULL
+                        && self.supports_is_not_null_alias(NotSpaceNull) =>
+                {
                     Ok(p!(Is))
                 }
                 _ => Ok(self.prec_unknown()),
             },
-            Token::Word(w) if w.keyword == Keyword::NOTNULL && self.supports_notnull() => {
+            Token::Word(w)
+                if w.keyword == Keyword::NOTNULL && self.supports_is_not_null_alias(NotNull) =>
+            {
                 Ok(p!(Is))
             }
             Token::Word(w) if w.keyword == Keyword::IS => Ok(p!(Is)),
@@ -1083,14 +1089,13 @@ pub trait Dialect: Debug + Any {
         false
     }
 
-    /// Returns true if the dialect supports `NOTNULL` in expressions.
-    fn supports_notnull(&self) -> bool {
-        false
-    }
-
-    /// Returns true if the dialect supports `NOT NULL` in expressions.
-    fn supports_not_null(&self) -> bool {
-        false
+    /// Returns true if the dialect supports the passed in alias.
+    /// See [IsNotNullAlias].
+    fn supports_is_not_null_alias(&self, alias: IsNotNullAlias) -> bool {
+        match alias {
+            NotNull => false,
+            NotSpaceNull => false,
+        }
     }
 }
 
@@ -1118,6 +1123,13 @@ pub enum Precedence {
     Or,
 }
 
+/// Possible aliases for `IS NOT NULL` supported
+/// by some non-standard dialects.
+pub enum IsNotNullAlias {
+    NotNull,
+    NotSpaceNull,
+}
+
 impl dyn Dialect {
     #[inline]
     pub fn is<T: Dialect>(&self) -> bool {
diff --git a/src/dialect/postgresql.rs b/src/dialect/postgresql.rs
@@ -28,7 +28,7 @@
 // limitations under the License.
 use log::debug;
 
-use crate::dialect::{Dialect, Precedence};
+use crate::dialect::{Dialect, IsNotNullAlias, Precedence};
 use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
 use crate::tokenizer::Token;
@@ -263,7 +263,12 @@ impl Dialect for PostgreSqlDialect {
         true
     }
 
-    fn supports_notnull(&self) -> bool {
-        true
+    /// Postgres supports `NOTNULL` as an alias for `IS NOT NULL`
+    /// but does not support `NOT NULL`.  See: <https://www.postgresql.org/docs/17/functions-comparison.html>
+    fn supports_is_not_null_alias(&self, alias: IsNotNullAlias) -> bool {
+        match alias {
+            IsNotNullAlias::NotNull => true,
+            IsNotNullAlias::NotSpaceNull => false,
+        }
     }
 }
diff --git a/src/dialect/sqlite.rs b/src/dialect/sqlite.rs
@@ -20,7 +20,7 @@ use alloc::boxed::Box;
 
 use crate::ast::BinaryOperator;
 use crate::ast::{Expr, Statement};
-use crate::dialect::Dialect;
+use crate::dialect::{Dialect, IsNotNullAlias};
 use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
 
@@ -111,11 +111,12 @@ impl Dialect for SQLiteDialect {
         true
     }
 
-    fn supports_not_null(&self) -> bool {
-        true
-    }
-
-    fn supports_notnull(&self) -> bool {
-        true
+    /// SQLite supports ``NOT NULL` and `NOTNULL` as
+    /// aliases for `IS NOT NULL`, see: <https://sqlite.org/syntax/expr.html>
+    fn supports_is_not_null_alias(&self, alias: IsNotNullAlias) -> bool {
+        match alias {
+            IsNotNullAlias::NotNull => true,
+            IsNotNullAlias::NotSpaceNull => true,
+        }
     }
 }
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -35,6 +35,7 @@ use IsOptional::*;
 use crate::ast::helpers::stmt_create_table::{CreateTableBuilder, CreateTableConfiguration};
 use crate::ast::Statement::CreatePolicy;
 use crate::ast::*;
+use crate::dialect::IsNotNullAlias::{NotNull, NotSpaceNull};
 use crate::dialect::*;
 use crate::keywords::{Keyword, ALL_KEYWORDS};
 use crate::tokenizer::*;
@@ -3572,10 +3573,10 @@ impl<'a> Parser<'a> {
                             ),
                             regexp,
                         })
-                    } else if dialect.supports_not_null() && negated && null {
+                    } else if dialect.supports_is_not_null_alias(NotSpaceNull) && negated && null {
                         Ok(Expr::NotNull {
                             expr: Box::new(expr),
-                            one_word: false,
+                            with_space: true,
                         })
                     } else if self.parse_keyword(Keyword::IN) {
                         self.parse_in(expr, negated)
@@ -3614,10 +3615,12 @@ impl<'a> Parser<'a> {
                         self.expected("IN or BETWEEN after NOT", self.peek_token())
                     }
                 }
-                Keyword::NOTNULL if dialect.supports_notnull() => Ok(Expr::NotNull {
-                    expr: Box::new(expr),
-                    one_word: true,
-                }),
+                Keyword::NOTNULL if dialect.supports_is_not_null_alias(NotNull) => {
+                    Ok(Expr::NotNull {
+                        expr: Box::new(expr),
+                        with_space: false,
+                    })
+                }
                 Keyword::MEMBER => {
                     if self.parse_keyword(Keyword::OF) {
                         self.expect_token(&Token::LParen)?;
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -32,8 +32,8 @@ use sqlparser::ast::TableFactor::{Pivot, Unpivot};
 use sqlparser::ast::*;
 use sqlparser::dialect::{
     AnsiDialect, BigQueryDialect, ClickHouseDialect, DatabricksDialect, Dialect, DuckDbDialect,
-    GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, RedshiftSqlDialect,
-    SQLiteDialect, SnowflakeDialect,
+    GenericDialect, HiveDialect, IsNotNullAlias, MsSqlDialect, MySqlDialect, PostgreSqlDialect,
+    RedshiftSqlDialect, SQLiteDialect, SnowflakeDialect,
 };
 use sqlparser::keywords::{Keyword, ALL_KEYWORDS};
 use sqlparser::parser::{Parser, ParserError, ParserOptions};
@@ -15980,7 +15980,8 @@ fn parse_not_null_unsupported() {
     // Only DuckDB and SQLite support `x NOT NULL` as an expression
     // All other dialects fail to parse.
     let sql = r#"WITH t AS (SELECT NULL AS x) SELECT x NOT NULL FROM t"#;
-    let dialects = all_dialects_except(|d| d.supports_not_null());
+    let dialects =
+        all_dialects_except(|d| d.supports_is_not_null_alias(IsNotNullAlias::NotSpaceNull));
     let res = dialects.parse_sql_statements(sql);
     assert_eq!(
         ParserError::ParserError("Expected: end of statement, found: NULL".to_string()),
@@ -15992,7 +15993,8 @@ fn parse_not_null_unsupported() {
 fn parse_not_null_supported() {
     // DuckDB and SQLite support `x NOT NULL` as an expression
     let sql = r#"WITH t AS (SELECT NULL AS x) SELECT x NOT NULL FROM t"#;
-    let dialects = all_dialects_where(|d| d.supports_not_null());
+    let dialects =
+        all_dialects_where(|d| d.supports_is_not_null_alias(IsNotNullAlias::NotSpaceNull));
     let stmt = dialects.one_statement_parses_to(sql, sql);
     match stmt {
         Statement::Query(qry) => match *qry.body {
@@ -16012,7 +16014,7 @@ fn parse_not_null_supported() {
                                     quote_style: None,
                                     span: fake_span,
                                 })),
-                                one_word: false,
+                                with_space: true,
                             },
                         );
                     }
@@ -16032,7 +16034,7 @@ fn parse_notnull_unsupported() {
     // consider `NOTNULL` an alias for x.
     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 AS NOTNULL FROM t"#;
-    let dialects = all_dialects_except(|d| d.supports_notnull());
+    let dialects = all_dialects_except(|d| d.supports_is_not_null_alias(IsNotNullAlias::NotNull));
     let stmt = dialects.one_statement_parses_to(sql, canonical);
     match stmt {
         Statement::Query(qry) => match *qry.body {
@@ -16074,7 +16076,7 @@ fn parse_notnull_unsupported() {
 fn parse_notnull_supported() {
     // DuckDB and SQLite support `x NOT NULL` as an expression
     let sql = r#"WITH t AS (SELECT NULL AS x) SELECT x NOTNULL FROM t"#;
-    let dialects = all_dialects_where(|d| d.supports_notnull());
+    let dialects = all_dialects_where(|d| d.supports_is_not_null_alias(IsNotNullAlias::NotNull));
     let stmt = dialects.one_statement_parses_to(sql, "");
     match stmt {
         Statement::Query(qry) => match *qry.body {
@@ -16094,7 +16096,7 @@ fn parse_notnull_supported() {
                                     quote_style: None,
                                     span: fake_span,
                                 })),
-                                one_word: true,
+                                with_space: false,
                             },
                         );
                     }
