MySQL: Support ALTER TABLE RENAME AS

src/ast/ddl.rs

@@ -33,11 +33,11 @@ use crate::ast::{
     display_comma_separated, display_separated, ArgMode, CommentDef, CreateFunctionBody,
     CreateFunctionUsing, DataType, Expr, FunctionBehavior, FunctionCalledOnNull,
     FunctionDeterminismSpecifier, FunctionParallel, Ident, IndexColumn, MySQLColumnPosition,
-    ObjectName, OperateFunctionArg, OrderByExpr, ProjectionSelect, SequenceOptions, SqlOption, Tag,
-    Value, ValueWithSpan,
+    ObjectName, OperateFunctionArg, OrderByExpr, ProjectionSelect, SequenceOptions, Spanned,
+    SqlOption, Tag, Value, ValueWithSpan,
 };
 use crate::keywords::Keyword;
-use crate::tokenizer::Token;
+use crate::tokenizer::{Span, Token};
 
 /// ALTER TABLE operation REPLICA IDENTITY values
 /// See [Postgres ALTER TABLE docs](https://www.postgresql.org/docs/current/sql-altertable.html)
@@ -264,7 +264,7 @@ pub enum AlterTableOperation {
     },
     /// `RENAME TO <table_name>`
     RenameTable {
-        table_name: ObjectName,
+        table_name: RenameTableNameKind,
     },
     // CHANGE [ COLUMN ] <old_name> <new_name> <data_type> [ <options> ]
     ChangeColumn {
@@ -687,7 +687,7 @@ impl fmt::Display for AlterTableOperation {
                 new_column_name,
             } => write!(f, "RENAME COLUMN {old_column_name} TO {new_column_name}"),
             AlterTableOperation::RenameTable { table_name } => {
-                write!(f, "RENAME TO {table_name}")
+                write!(f, "RENAME {table_name}")
             }
             AlterTableOperation::ChangeColumn {
                 old_name,
@@ -2524,3 +2524,34 @@ impl fmt::Display for CreateConnector {
         Ok(())
     }
 }
+
+/// `RenameTableNameKind` is the kind used in an `ALTER TABLE _ RENAME` statement.
+///
+/// Note: [MySQL] is the only database that supports the AS keyword for this operation.
+///
+/// [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 RenameTableNameKind {
+    As(ObjectName),
+    To(ObjectName),
+}
+
+impl fmt::Display for RenameTableNameKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            RenameTableNameKind::As(name) => write!(f, "AS {name}"),
+            RenameTableNameKind::To(name) => write!(f, "TO {name}"),
+        }
+    }
+}
+
+impl Spanned for RenameTableNameKind {
+    fn span(&self) -> Span {
+        match self {
+            RenameTableNameKind::As(name) => name.span(),
+            RenameTableNameKind::To(name) => name.span(),
+        }
+    }
+}

src/ast/mod.rs

@@ -66,9 +66,9 @@ pub use self::ddl::{
     Deduplicate, DeferrableInitial, DropBehavior, GeneratedAs, GeneratedExpressionMode,
     IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
     IdentityPropertyOrder, IndexOption, IndexType, KeyOrIndexDisplay, NullsDistinctOption, Owner,
-    Partition, ProcedureParam, ReferentialAction, ReplicaIdentity, TableConstraint,
-    TagsColumnOption, UserDefinedTypeCompositeAttributeDef, UserDefinedTypeRepresentation,
-    ViewColumnDef,
+    Partition, ProcedureParam, ReferentialAction, RenameTableNameKind, ReplicaIdentity,
+    TableConstraint, TagsColumnOption, UserDefinedTypeCompositeAttributeDef,
+    UserDefinedTypeRepresentation, ViewColumnDef,
 };
 pub use self::dml::{CreateIndex, CreateTable, Delete, IndexColumn, Insert};
 pub use self::operator::{BinaryOperator, UnaryOperator};

src/parser/mod.rs

@@ -8647,7 +8647,14 @@ impl<'a> Parser<'a> {
                 AlterTableOperation::RenameConstraint { old_name, new_name }
             } else if self.parse_keyword(Keyword::TO) {
                 let table_name = self.parse_object_name(false)?;
-                AlterTableOperation::RenameTable { table_name }
+                AlterTableOperation::RenameTable {
+                    table_name: RenameTableNameKind::To(table_name),
+                }
+            } else if self.parse_keyword(Keyword::AS) {
+                let table_name = self.parse_object_name(false)?;
+                AlterTableOperation::RenameTable {
+                    table_name: RenameTableNameKind::As(table_name),
+                }
             } else {
                 let _ = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ]
                 let old_column_name = self.parse_identifier()?;

tests/sqlparser_common.rs

@@ -4690,7 +4690,21 @@ fn parse_alter_table() {
     let rename_table = "ALTER TABLE tab RENAME TO new_tab";
     match alter_table_op(verified_stmt(rename_table)) {
         AlterTableOperation::RenameTable { table_name } => {
-            assert_eq!("new_tab", table_name.to_string());
+            assert_eq!(
+                RenameTableNameKind::To(ObjectName::from(vec![Ident::new("new_tab")])),
+                table_name
+            );
+        }
+        _ => unreachable!(),
+    };
+
+    let rename_table_as = "ALTER TABLE tab RENAME AS new_tab";
+    match alter_table_op(verified_stmt(rename_table_as)) {
+        AlterTableOperation::RenameTable { table_name } => {
+            assert_eq!(
+                RenameTableNameKind::As(ObjectName::from(vec![Ident::new("new_tab")])),
+                table_name
+            );
         }
         _ => unreachable!(),
     };