fixup: Add ParserState::ColumnDefinition to avoid parsing NOT NULL as Expr::IsNotNull.

Author: ryanschneider

src/dialect/mod.rs

@@ -650,6 +650,9 @@ 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 && parser.in_normal_state() => {
+                    Ok(p!(Is))
+                }
                 _ => Ok(self.prec_unknown()),
             },
             Token::Word(w) if w.keyword == Keyword::NOTNULL && self.supports_notnull_operator() => {

src/parser/mod.rs

@@ -28,16 +28,16 @@ use helpers::attached_token::AttachedToken;
 
 use log::debug;
 
-use recursion::RecursionCounter;
-use IsLateral::*;
-use IsOptional::*;
-
 use crate::ast::helpers::stmt_create_table::{CreateTableBuilder, CreateTableConfiguration};
 use crate::ast::Statement::CreatePolicy;
 use crate::ast::*;
 use crate::dialect::*;
 use crate::keywords::{Keyword, ALL_KEYWORDS};
 use crate::tokenizer::*;
+use recursion::RecursionCounter;
+use sqlparser::parser::ParserState::ColumnDefinition;
+use IsLateral::*;
+use IsOptional::*;
 
 mod alter;
 
@@ -271,6 +271,9 @@ enum ParserState {
     /// PRIOR expressions while still allowing prior as an identifier name
     /// in other contexts.
     ConnectBy,
+    /// The state when parsing column definitions.  This state prohibits
+    /// NOT NULL as an alias for IS NOT NULL.
+    ColumnDefinition,
 }
 
 /// A SQL Parser
@@ -1243,21 +1246,6 @@ impl<'a> Parser<'a> {
 
             expr = self.parse_infix(expr, next_precedence)?;
         }
-
-        // Special case: if expr is an identifier or NULL, accept `expr NOT NULL`
-        // as an alias for `expr IS NOT NULL`.
-        if match &expr {
-            Expr::Identifier(_) if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) => true,
-            Expr::Value(v)
-                if v.value == Value::Null
-                    && self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) =>
-            {
-                true
-            }
-            _ => false,
-        } {
-            return Ok(Expr::IsNotNull(Box::new(expr)));
-        }
         Ok(expr)
     }
 
@@ -3577,6 +3565,11 @@ impl<'a> Parser<'a> {
                     let negated = self.parse_keyword(Keyword::NOT);
                     let regexp = self.parse_keyword(Keyword::REGEXP);
                     let rlike = self.parse_keyword(Keyword::RLIKE);
+                    let null = if self.in_normal_state() {
+                        self.parse_keyword(Keyword::NULL)
+                    } else {
+                        false
+                    };
                     if regexp || rlike {
                         Ok(Expr::RLike {
                             negated,
@@ -3586,6 +3579,8 @@ impl<'a> Parser<'a> {
                             ),
                             regexp,
                         })
+                    } else if negated && null {
+                        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) {
@@ -7734,6 +7729,15 @@ impl<'a> Parser<'a> {
             return option;
         }
 
+        self.with_state(
+            ColumnDefinition,
+            |parser| -> Result<Option<ColumnOption>, ParserError> {
+                parser.parse_optional_column_option_inner()
+            },
+        )
+    }
+
+    fn parse_optional_column_option_inner(&mut self) -> Result<Option<ColumnOption>, ParserError> {
         if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
             Ok(Some(ColumnOption::CharacterSet(
                 self.parse_object_name(false)?,
@@ -16510,6 +16514,10 @@ impl<'a> Parser<'a> {
             Ok(None)
         }
     }
+
+    pub fn in_normal_state(&self) -> bool {
+        matches!(self.state, ParserState::Normal)
+    }
 }
 
 fn maybe_prefixed_expr(expr: Expr, prefix: Option<Ident>) -> Expr {