Add support for MySQL ALTER TABLE options

Implemented parsing for MySQL-specific ALTER TABLE options:
- CHECKSUM [=] {0 | 1}
- DELAY_KEY_WRITE [=] {0 | 1}
- FORCE
- ROW_FORMAT [=] {DEFAULT | DYNAMIC | FIXED | COMPRESSED | REDUNDANT | COMPACT}
- STATS_AUTO_RECALC [=] {DEFAULT | 0 | 1}

Added new keywords in alphabetical order:
- COMPACT, COMPRESSED, FIXED, REDUNDANT

Added AST types:
- AlterTableRowFormat enum
- AlterTableStatsAutoRecalc enum
- AlterTableOperation variants for each option

Includes tests for individual options and combined usage.

Author: claude

src/ast/ddl.rs

@@ -411,6 +411,48 @@ pub enum AlterTableOperation {
         equals: bool,
         value: ValueWithSpan,
     },
+    /// `CHECKSUM [=] {0 | 1}`
+    ///
+    /// [MySQL]-specific table option for checksum.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    Checksum {
+        equals: bool,
+        value: u8,
+    },
+    /// `DELAY_KEY_WRITE [=] {0 | 1}`
+    ///
+    /// [MySQL]-specific table option for delay key write.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    DelayKeyWrite {
+        equals: bool,
+        value: u8,
+    },
+    /// `FORCE`
+    ///
+    /// [MySQL]-specific table option to force table rebuild.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    Force,
+    /// `ROW_FORMAT [=] <format>`
+    ///
+    /// [MySQL]-specific table option for row format.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    RowFormat {
+        equals: bool,
+        format: AlterTableRowFormat,
+    },
+    /// `STATS_AUTO_RECALC [=] {DEFAULT | 0 | 1}`
+    ///
+    /// [MySQL]-specific table option for stats auto recalc.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    StatsAutoRecalc {
+        equals: bool,
+        value: AlterTableStatsAutoRecalc,
+    },
     /// `VALIDATE CONSTRAINT <name>`
     ValidateConstraint {
         name: Ident,
@@ -518,6 +560,56 @@ impl fmt::Display for AlterTableLock {
     }
 }
 
+/// [MySQL] `ALTER TABLE` row format.
+///
+/// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTableRowFormat {
+    Default,
+    Dynamic,
+    Fixed,
+    Compressed,
+    Redundant,
+    Compact,
+}
+
+impl fmt::Display for AlterTableRowFormat {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            Self::Default => "DEFAULT",
+            Self::Dynamic => "DYNAMIC",
+            Self::Fixed => "FIXED",
+            Self::Compressed => "COMPRESSED",
+            Self::Redundant => "REDUNDANT",
+            Self::Compact => "COMPACT",
+        })
+    }
+}
+
+/// [MySQL] `ALTER TABLE` stats auto recalc.
+///
+/// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTableStatsAutoRecalc {
+    Default,
+    Zero,
+    One,
+}
+
+impl fmt::Display for AlterTableStatsAutoRecalc {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            Self::Default => "DEFAULT",
+            Self::Zero => "0",
+            Self::One => "1",
+        })
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
@@ -880,6 +972,21 @@ impl fmt::Display for AlterTableOperation {
                     value
                 )
             }
+            AlterTableOperation::Checksum { equals, value } => {
+                write!(f, "CHECKSUM {}{}", if *equals { "= " } else { "" }, value)
+            }
+            AlterTableOperation::DelayKeyWrite { equals, value } => {
+                write!(f, "DELAY_KEY_WRITE {}{}", if *equals { "= " } else { "" }, value)
+            }
+            AlterTableOperation::Force => {
+                write!(f, "FORCE")
+            }
+            AlterTableOperation::RowFormat { equals, format } => {
+                write!(f, "ROW_FORMAT {}{}", if *equals { "= " } else { "" }, format)
+            }
+            AlterTableOperation::StatsAutoRecalc { equals, value } => {
+                write!(f, "STATS_AUTO_RECALC {}{}", if *equals { "= " } else { "" }, value)
+            }
             AlterTableOperation::Lock { equals, lock } => {
                 write!(f, "LOCK {}{}", if *equals { "= " } else { "" }, lock)
             }

src/ast/mod.rs

@@ -61,7 +61,8 @@ pub use self::dcl::{
 pub use self::ddl::{
     Alignment, AlterColumnOperation, AlterConnectorOwner, AlterIndexOperation,
     AlterPolicyOperation, AlterSchema, AlterSchemaOperation, AlterTable, AlterTableAlgorithm,
-    AlterTableLock, AlterTableOperation, AlterTableType, AlterType, AlterTypeAddValue,
+    AlterTableLock, AlterTableOperation, AlterTableRowFormat, AlterTableStatsAutoRecalc,
+    AlterTableType, AlterType, AlterTypeAddValue,
     AlterTypeAddValuePosition, AlterTypeOperation, AlterTypeRename, AlterTypeRenameValue,
     ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnOptions, ColumnPolicy,
     ColumnPolicyProperty, ConstraintCharacteristics, CreateConnector, CreateDomain,

src/ast/spans.rs

@@ -1149,6 +1149,11 @@ impl Spanned for AlterTableOperation {
             AlterTableOperation::Resume => Span::empty(),
             AlterTableOperation::Algorithm { .. } => Span::empty(),
             AlterTableOperation::AutoIncrement { value, .. } => value.span(),
+            AlterTableOperation::Checksum { .. } => Span::empty(),
+            AlterTableOperation::DelayKeyWrite { .. } => Span::empty(),
+            AlterTableOperation::Force => Span::empty(),
+            AlterTableOperation::RowFormat { .. } => Span::empty(),
+            AlterTableOperation::StatsAutoRecalc { .. } => Span::empty(),
             AlterTableOperation::Lock { .. } => Span::empty(),
             AlterTableOperation::ReplicaIdentity { .. } => Span::empty(),
             AlterTableOperation::ValidateConstraint { name } => name.span,

src/keywords.rs

@@ -219,7 +219,9 @@ define_keywords!(
     COMMIT,
     COMMITTED,
     COMMUTATOR,
+    COMPACT,
     COMPATIBLE,
+    COMPRESSED,
     COMPRESSION,
     COMPUPDATE,
     COMPUTE,
@@ -398,6 +400,7 @@ define_keywords!(
     FINAL,
     FIRST,
     FIRST_VALUE,
+    FIXED,
     FIXEDSTRING,
     FIXEDWIDTH,
     FLATTEN,
@@ -800,6 +803,7 @@ define_keywords!(
     RECEIVE,
     RECLUSTER,
     RECURSIVE,
+    REDUNDANT,
     REF,
     REFERENCES,
     REFERENCING,

src/parser/mod.rs

@@ -9681,6 +9681,103 @@ impl<'a> Parser<'a> {
             let equals = self.consume_token(&Token::Eq);
             let value = self.parse_number_value()?;
             AlterTableOperation::AutoIncrement { equals, value }
+        } else if self.parse_keyword(Keyword::CHECKSUM) {
+            let equals = self.consume_token(&Token::Eq);
+            let num = self.parse_number_value()?;
+            let value_u8 = match &num.value {
+                #[cfg(not(feature = "bigdecimal"))]
+                Value::Number(s, _) => match s.as_str() {
+                    "0" => 0,
+                    "1" => 1,
+                    _ => return self.expected("0 or 1 after CHECKSUM [=]", self.peek_token()),
+                },
+                #[cfg(feature = "bigdecimal")]
+                Value::Number(n, _) => {
+                    if n == &0.into() {
+                        0
+                    } else if n == &1.into() {
+                        1
+                    } else {
+                        return self.expected("0 or 1 after CHECKSUM [=]", self.peek_token())
+                    }
+                }
+                _ => return self.expected("0 or 1 after CHECKSUM [=]", self.peek_token()),
+            };
+            AlterTableOperation::Checksum { equals, value: value_u8 }
+        } else if self.parse_keyword(Keyword::DELAY_KEY_WRITE) {
+            let equals = self.consume_token(&Token::Eq);
+            let num = self.parse_number_value()?;
+            let value_u8 = match &num.value {
+                #[cfg(not(feature = "bigdecimal"))]
+                Value::Number(s, _) => match s.as_str() {
+                    "0" => 0,
+                    "1" => 1,
+                    _ => return self.expected("0 or 1 after DELAY_KEY_WRITE [=]", self.peek_token()),
+                },
+                #[cfg(feature = "bigdecimal")]
+                Value::Number(n, _) => {
+                    if n == &0.into() {
+                        0
+                    } else if n == &1.into() {
+                        1
+                    } else {
+                        return self.expected("0 or 1 after DELAY_KEY_WRITE [=]", self.peek_token())
+                    }
+                }
+                _ => return self.expected("0 or 1 after DELAY_KEY_WRITE [=]", self.peek_token()),
+            };
+            AlterTableOperation::DelayKeyWrite { equals, value: value_u8 }
+        } else if self.parse_keyword(Keyword::FORCE) {
+            AlterTableOperation::Force
+        } else if self.parse_keyword(Keyword::ROW_FORMAT) {
+            let equals = self.consume_token(&Token::Eq);
+            let format = match self.parse_one_of_keywords(&[
+                Keyword::DEFAULT,
+                Keyword::DYNAMIC,
+                Keyword::FIXED,
+                Keyword::COMPRESSED,
+                Keyword::REDUNDANT,
+                Keyword::COMPACT,
+            ]) {
+                Some(Keyword::DEFAULT) => AlterTableRowFormat::Default,
+                Some(Keyword::DYNAMIC) => AlterTableRowFormat::Dynamic,
+                Some(Keyword::FIXED) => AlterTableRowFormat::Fixed,
+                Some(Keyword::COMPRESSED) => AlterTableRowFormat::Compressed,
+                Some(Keyword::REDUNDANT) => AlterTableRowFormat::Redundant,
+                Some(Keyword::COMPACT) => AlterTableRowFormat::Compact,
+                _ => self.expected(
+                    "DEFAULT, DYNAMIC, FIXED, COMPRESSED, REDUNDANT, or COMPACT after ROW_FORMAT [=]",
+                    self.peek_token(),
+                )?,
+            };
+            AlterTableOperation::RowFormat { equals, format }
+        } else if self.parse_keyword(Keyword::STATS_AUTO_RECALC) {
+            let equals = self.consume_token(&Token::Eq);
+            let value = if self.parse_keyword(Keyword::DEFAULT) {
+                AlterTableStatsAutoRecalc::Default
+            } else {
+                let num = self.parse_number_value()?;
+                match &num.value {
+                    #[cfg(not(feature = "bigdecimal"))]
+                    Value::Number(s, _) => match s.as_str() {
+                        "0" => AlterTableStatsAutoRecalc::Zero,
+                        "1" => AlterTableStatsAutoRecalc::One,
+                        _ => return self.expected("DEFAULT, 0, or 1 after STATS_AUTO_RECALC [=]", self.peek_token()),
+                    },
+                    #[cfg(feature = "bigdecimal")]
+                    Value::Number(n, _) => {
+                        if n == &0.into() {
+                            AlterTableStatsAutoRecalc::Zero
+                        } else if n == &1.into() {
+                            AlterTableStatsAutoRecalc::One
+                        } else {
+                            return self.expected("DEFAULT, 0, or 1 after STATS_AUTO_RECALC [=]", self.peek_token())
+                        }
+                    }
+                    _ => return self.expected("DEFAULT, 0, or 1 after STATS_AUTO_RECALC [=]", self.peek_token()),
+                }
+            };
+            AlterTableOperation::StatsAutoRecalc { equals, value }
         } else if self.parse_keywords(&[Keyword::REPLICA, Keyword::IDENTITY]) {
             let identity = if self.parse_keyword(Keyword::NONE) {
                 ReplicaIdentity::None

tests/sqlparser_mysql.rs

@@ -3136,6 +3136,90 @@ fn parse_alter_table_auto_increment() {
     mysql_and_generic().verified_stmt("ALTER TABLE `users` AUTO_INCREMENT 42");
 }
 
+#[test]
+fn parse_alter_table_checksum() {
+    let sql = "ALTER TABLE tab CHECKSUM = 1";
+    let expected_operation = AlterTableOperation::Checksum {
+        equals: true,
+        value: 1,
+    };
+    let operation = alter_table_op(mysql().verified_stmt(sql));
+    assert_eq!(expected_operation, operation);
+
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` CHECKSUM 0");
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` CHECKSUM = 1");
+}
+
+#[test]
+fn parse_alter_table_delay_key_write() {
+    let sql = "ALTER TABLE tab DELAY_KEY_WRITE = 0";
+    let expected_operation = AlterTableOperation::DelayKeyWrite {
+        equals: true,
+        value: 0,
+    };
+    let operation = alter_table_op(mysql().verified_stmt(sql));
+    assert_eq!(expected_operation, operation);
+
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` DELAY_KEY_WRITE 1");
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` DELAY_KEY_WRITE = 0");
+}
+
+#[test]
+fn parse_alter_table_force() {
+    let sql = "ALTER TABLE tab FORCE";
+    let expected_operation = AlterTableOperation::Force;
+    let operation = alter_table_op(mysql().verified_stmt(sql));
+    assert_eq!(expected_operation, operation);
+}
+
+#[test]
+fn parse_alter_table_row_format() {
+    let sql = "ALTER TABLE tab ROW_FORMAT = COMPACT";
+    let expected_operation = AlterTableOperation::RowFormat {
+        equals: true,
+        format: AlterTableRowFormat::Compact,
+    };
+    let operation = alter_table_op(mysql().verified_stmt(sql));
+    assert_eq!(expected_operation, operation);
+
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` ROW_FORMAT DEFAULT");
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` ROW_FORMAT = DYNAMIC");
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` ROW_FORMAT = FIXED");
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` ROW_FORMAT = COMPRESSED");
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` ROW_FORMAT = REDUNDANT");
+}
+
+#[test]
+fn parse_alter_table_stats_auto_recalc() {
+    let sql = "ALTER TABLE tab STATS_AUTO_RECALC = 1";
+    let expected_operation = AlterTableOperation::StatsAutoRecalc {
+        equals: true,
+        value: AlterTableStatsAutoRecalc::One,
+    };
+    let operation = alter_table_op(mysql().verified_stmt(sql));
+    assert_eq!(expected_operation, operation);
+
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` STATS_AUTO_RECALC 0");
+    mysql_and_generic().verified_stmt("ALTER TABLE `users` STATS_AUTO_RECALC = DEFAULT");
+}
+
+#[test]
+fn parse_alter_table_multiple_table_options() {
+    let sql = "ALTER TABLE t0 CHECKSUM 1, ALGORITHM COPY, DELAY_KEY_WRITE 0, FORCE, STATS_AUTO_RECALC 1, ROW_FORMAT COMPACT";
+    match mysql().verified_stmt(sql) {
+        Statement::AlterTable(AlterTable { operations, .. }) => {
+            assert_eq!(operations.len(), 6);
+            assert_eq!(operations[0], AlterTableOperation::Checksum { equals: false, value: 1 });
+            assert_eq!(operations[1], AlterTableOperation::Algorithm { equals: false, algorithm: AlterTableAlgorithm::Copy });
+            assert_eq!(operations[2], AlterTableOperation::DelayKeyWrite { equals: false, value: 0 });
+            assert_eq!(operations[3], AlterTableOperation::Force);
+            assert_eq!(operations[4], AlterTableOperation::StatsAutoRecalc { equals: false, value: AlterTableStatsAutoRecalc::One });
+            assert_eq!(operations[5], AlterTableOperation::RowFormat { equals: false, format: AlterTableRowFormat::Compact });
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_alter_table_modify_column_with_column_position() {
     let expected_name = ObjectName::from(vec![Ident::new("orders")]);