fixup: address next round of feedback

Author: ryanschneider

src/parser/mod.rs

@@ -7787,7 +7787,7 @@ impl<'a> Parser<'a> {
         } else if dialect_of!(self is ClickHouseDialect| GenericDialect)
             && self.parse_keyword(Keyword::ALIAS)
         {
-            Ok(Some(ColumnOption::Alias(self.parse_expr()?)))
+            Ok(Some(ColumnOption::Alias(self.parse_column_option_expr()?)))
         } else if dialect_of!(self is ClickHouseDialect| GenericDialect)
             && self.parse_keyword(Keyword::EPHEMERAL)
         {
@@ -7796,7 +7796,9 @@ impl<'a> Parser<'a> {
             if matches!(self.peek_token().token, Token::Comma | Token::RParen) {
                 Ok(Some(ColumnOption::Ephemeral(None)))
             } else {
-                Ok(Some(ColumnOption::Ephemeral(Some(self.parse_expr()?))))
+                Ok(Some(ColumnOption::Ephemeral(Some(
+                    self.parse_column_option_expr()?,
+                ))))
             }
         } else if self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) {
             let characteristics = self.parse_constraint_characteristics()?;
@@ -7874,7 +7876,7 @@ impl<'a> Parser<'a> {
         } else if self.parse_keywords(&[Keyword::ON, Keyword::UPDATE])
             && dialect_of!(self is MySqlDialect | GenericDialect)
         {
-            let expr = self.parse_expr()?;
+            let expr = self.parse_column_option_expr()?;
             Ok(Some(ColumnOption::OnUpdate(expr)))
         } else if self.parse_keyword(Keyword::GENERATED) {
             self.parse_optional_column_option_generated()
@@ -7892,7 +7894,9 @@ impl<'a> Parser<'a> {
         } else if self.parse_keyword(Keyword::SRID)
             && dialect_of!(self is MySqlDialect | GenericDialect)
         {
-            Ok(Some(ColumnOption::Srid(Box::new(self.parse_expr()?))))
+            Ok(Some(ColumnOption::Srid(Box::new(
+                self.parse_column_option_expr()?,
+            ))))
         } else if self.parse_keyword(Keyword::IDENTITY)
             && dialect_of!(self is MsSqlDialect | GenericDialect)
         {
@@ -7934,7 +7938,7 @@ impl<'a> Parser<'a> {
 
     /// When parsing some column option expressions we need to revert to [ParserState::Normal] since
     /// `NOT NULL` is allowed as an alias for `IS NOT NULL`.
-    /// In those cases we use this helper instead of calling [parse_expr] directly.
+    /// In those cases we use this helper instead of calling [Parser::parse_expr] directly.
     ///
     /// For example, consider these `CREATE TABLE` statements:
     /// ```sql

tests/sqlparser_common.rs

@@ -16032,13 +16032,10 @@ fn parse_create_procedure_with_parameter_modes() {
 }
 
 #[test]
-fn parse_not_null_supported() {
+fn parse_not_null() {
     let _ = all_dialects().expr_parses_to("x NOT NULL", "x IS NOT NULL");
     let _ = all_dialects().expr_parses_to("NULL NOT NULL", "NULL IS NOT NULL");
-}
 
-#[test]
-fn test_not_null_precedence() {
     assert_matches!(
         all_dialects().expr_parses_to("NOT NULL NOT NULL", "NOT NULL IS NOT NULL"),
         Expr::UnaryOp {
@@ -16200,37 +16197,27 @@ fn test_identifier_unicode_start() {
 }
 
 #[test]
-fn parse_notnull_unsupported() {
-    // Only Postgres, DuckDB, and SQLite support `x NOTNULL` as an expression
-    // All other dialects consider `x NOTNULL` like `x AS NOTNULL` and thus
-    // consider `NOTNULL` an alias for x.
-    let dialects = all_dialects_except(|d| d.supports_notnull_operator());
-    let _ = dialects
+fn parse_notnull() {
+    // Some dialects support `x NOTNULL` as an expression while others consider
+    // `x NOTNULL` like `x AS NOTNULL` and thus consider `NOTNULL` an alias for x.
+    let notnull_unsupported_dialects = all_dialects_except(|d| d.supports_notnull_operator());
+    let _ = notnull_unsupported_dialects
         .verified_only_select_with_canonical("SELECT NULL NOTNULL", "SELECT NULL AS NOTNULL");
-}
 
-#[test]
-fn parse_notnull_supported() {
-    // Postgres, DuckDB and SQLite support `x NOTNULL` as an alias for `x IS NOT NULL`
-    let dialects = all_dialects_where(|d| d.supports_notnull_operator());
-    let _ = dialects.expr_parses_to("x NOTNULL", "x IS NOT NULL");
-}
+    // Supported dialects consider `x NOTNULL` as an alias for `x IS NOT NULL`
+    let notnull_supported_dialects = all_dialects_where(|d| d.supports_notnull_operator());
+    let _ = notnull_supported_dialects.expr_parses_to("x NOTNULL", "x IS NOT NULL");
 
-#[test]
-fn test_notnull_precedence() {
     // For dialects which support it, `NOT NULL NOTNULL` should
     // parse as `(NOT (NULL IS NOT NULL))`
-    let supported_dialects = all_dialects_where(|d| d.supports_notnull_operator());
-    let unsupported_dialects = all_dialects_except(|d| d.supports_notnull_operator());
-
     assert_matches!(
-        supported_dialects.expr_parses_to("NOT NULL NOTNULL", "NOT NULL IS NOT NULL"),
+        notnull_supported_dialects.expr_parses_to("NOT NULL NOTNULL", "NOT NULL IS NOT NULL"),
         Expr::UnaryOp {
             op: UnaryOperator::Not,
             ..
         }
     );
 
     // for unsupported dialects, parsing should stop at `NOT NULL`
-    unsupported_dialects.expr_parses_to("NOT NULL NOTNULL", "NOT NULL");
+    notnull_unsupported_dialects.expr_parses_to("NOT NULL NOTNULL", "NOT NULL");
 }