Fix column definition COLLATE parsing

Since `COLLATE` has somewhat special parsing (not handled as an infix
operator, since the right-hand side is not really an expression), it
also needs special handling to not allow parsing it in column
definitions, where it should instead be interpreted as a column option.

Author: mvzink

src/parser/mod.rs

@@ -1248,6 +1248,12 @@ impl<'a> Parser<'a> {
         debug!("parsing expr");
         let mut expr = self.parse_prefix()?;
 
+        // We would have returned early in `parse_prefix` before checking for `COLLATE`, and there's
+        // no infix operator handling for `COLLATE`, so we must return now.
+        if self.in_column_definition_state() && self.peek_keyword(Keyword::COLLATE) {
+            return Ok(expr);
+        }
+
         expr = self.parse_compound_expr(expr, vec![])?;
 
         debug!("prefix: {expr:?}");
@@ -1722,7 +1728,7 @@ impl<'a> Parser<'a> {
             _ => self.expected_at("an expression", next_token_index),
         }?;
 
-        if self.parse_keyword(Keyword::COLLATE) {
+        if !self.in_column_definition_state() && self.parse_keyword(Keyword::COLLATE) {
             Ok(Expr::Collate {
                 expr: Box::new(expr),
                 collation: self.parse_object_name(false)?,
@@ -3372,6 +3378,7 @@ impl<'a> Parser<'a> {
 
         self.advance_token();
         let tok = self.get_current_token();
+        debug!("infix: {tok:?}");
         let tok_index = self.get_current_index();
         let span = tok.span;
         let regular_binary_operator = match &tok.token {
@@ -17608,30 +17615,6 @@ mod tests {
         assert!(Parser::parse_sql(&MySqlDialect {}, sql).is_err());
     }
 
-    #[test]
-    fn test_parse_not_null_in_column_options() {
-        let canonical = concat!(
-            "CREATE TABLE foo (",
-            "abc INT DEFAULT (42 IS NOT NULL) NOT NULL,",
-            " def INT,",
-            " def_null BOOL GENERATED ALWAYS AS (def IS NOT NULL) STORED,",
-            " CHECK (abc IS NOT NULL)",
-            ")"
-        );
-        all_dialects().verified_stmt(canonical);
-        all_dialects().one_statement_parses_to(
-            concat!(
-                "CREATE TABLE foo (",
-                "abc INT DEFAULT (42 NOT NULL) NOT NULL,",
-                " def INT,",
-                " def_null BOOL GENERATED ALWAYS AS (def NOT NULL) STORED,",
-                " CHECK (abc NOT NULL)",
-                ")"
-            ),
-            canonical,
-        );
-    }
-
     #[test]
     fn test_placeholder_invalid_whitespace() {
         for w in ["  ", "/*invalid*/"] {

tests/sqlparser_common.rs

@@ -16565,3 +16565,60 @@ fn parse_create_view_if_not_exists() {
         res.unwrap_err()
     );
 }
+
+#[test]
+fn test_parse_not_null_in_column_options() {
+    let canonical = concat!(
+        "CREATE TABLE foo (",
+        "abc INT DEFAULT (42 IS NOT NULL) NOT NULL,",
+        " def INT,",
+        " def_null BOOL GENERATED ALWAYS AS (def IS NOT NULL) STORED,",
+        " CHECK (abc IS NOT NULL)",
+        ")"
+    );
+    all_dialects().verified_stmt(canonical);
+    all_dialects().one_statement_parses_to(
+        concat!(
+            "CREATE TABLE foo (",
+            "abc INT DEFAULT (42 NOT NULL) NOT NULL,",
+            " def INT,",
+            " def_null BOOL GENERATED ALWAYS AS (def NOT NULL) STORED,",
+            " CHECK (abc NOT NULL)",
+            ")"
+        ),
+        canonical,
+    );
+}
+
+#[test]
+fn test_parse_default_with_collate_column_option() {
+    let sql = "CREATE TABLE foo (abc TEXT DEFAULT 'foo' COLLATE 'en_US')";
+    let stmt = all_dialects().verified_stmt(sql);
+    if let Statement::CreateTable(CreateTable { mut columns, .. }) = stmt {
+        let mut column = columns.pop().unwrap();
+        assert_eq!(&column.name.value, "abc");
+        assert_eq!(column.data_type, DataType::Text);
+        let collate_option = column.options.pop().unwrap();
+        if let ColumnOptionDef {
+            name: None,
+            option: ColumnOption::Collation(collate),
+        } = collate_option
+        {
+            assert_eq!(collate.to_string(), "'en_US'");
+        } else {
+            panic!("Expected collate column option, got {collate_option}");
+        }
+        let default_option = column.options.pop().unwrap();
+        if let ColumnOptionDef {
+            name: None,
+            option: ColumnOption::Default(Expr::Value(value)),
+        } = default_option
+        {
+            assert_eq!(value.to_string(), "'foo'");
+        } else {
+            panic!("Expected default column option, got {default_option}");
+        }
+    } else {
+        panic!("Expected create table statement");
+    }
+}