Add support for Postgres ALTER TYPE {RENAME TO|{ADD|RENAME} VALUE}

jvatic · jvatic · commit f5993b36f1b1 · 2025-02-16T17:52:29.000-05:00
diff --git a/src/ast/ddl.rs b/src/ast/ddl.rs
@@ -640,6 +640,68 @@ impl fmt::Display for AlterIndexOperation {
     }
 }
 
+/// An `ALTER TYPE` (`Statement::AlterType`) operation
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTypeOperation {
+    Rename {
+        new_name: Ident,
+    },
+    AddValue {
+        if_not_exists: bool,
+        value: Ident,
+        position: AlterTypeOperationAddValuePosition,
+    },
+    RenameValue {
+        from: Ident,
+        to: Ident,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTypeOperationAddValuePosition {
+    Default,
+    Before(Ident),
+    After(Ident),
+}
+
+impl fmt::Display for AlterTypeOperation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Rename { new_name } => {
+                write!(f, "RENAME TO {new_name}")
+            }
+            Self::AddValue {
+                if_not_exists,
+                value,
+                position,
+            } => {
+                write!(f, "ADD VALUE")?;
+                if *if_not_exists {
+                    write!(f, " IF NOT EXISTS")?;
+                }
+                write!(f, " {value}")?;
+                match position {
+                    AlterTypeOperationAddValuePosition::Before(neighbor_value) => {
+                        write!(f, " BEFORE {neighbor_value}")?;
+                    }
+                    AlterTypeOperationAddValuePosition::After(neighbor_value) => {
+                        write!(f, " AFTER {neighbor_value}")?;
+                    }
+                    AlterTypeOperationAddValuePosition::Default => {}
+                };
+                Ok(())
+            }
+            Self::RenameValue { from, to } => {
+                write!(f, "RENAME VALUE {from} TO {to}")
+            }
+        }
+    }
+}
+
 /// An `ALTER COLUMN` (`Statement::AlterTable`) operation
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -48,13 +48,14 @@ pub use self::dcl::{
 };
 pub use self::ddl::{
     AlterColumnOperation, AlterConnectorOwner, AlterIndexOperation, AlterPolicyOperation,
-    AlterTableOperation, ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnPolicy,
-    ColumnPolicyProperty, ConstraintCharacteristics, CreateConnector, CreateFunction, Deduplicate,
-    DeferrableInitial, DropBehavior, GeneratedAs, GeneratedExpressionMode, IdentityParameters,
-    IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder,
-    IndexOption, IndexType, KeyOrIndexDisplay, NullsDistinctOption, Owner, Partition,
-    ProcedureParam, ReferentialAction, TableConstraint, TagsColumnOption,
-    UserDefinedTypeCompositeAttributeDef, UserDefinedTypeRepresentation, ViewColumnDef,
+    AlterTableOperation, AlterTypeOperation, AlterTypeOperationAddValuePosition, ClusteredBy,
+    ColumnDef, ColumnOption, ColumnOptionDef, ColumnPolicy, ColumnPolicyProperty,
+    ConstraintCharacteristics, CreateConnector, CreateFunction, Deduplicate, DeferrableInitial,
+    DropBehavior, GeneratedAs, GeneratedExpressionMode, IdentityParameters, IdentityProperty,
+    IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, IndexOption,
+    IndexType, KeyOrIndexDisplay, NullsDistinctOption, Owner, Partition, ProcedureParam,
+    ReferentialAction, TableConstraint, TagsColumnOption, UserDefinedTypeCompositeAttributeDef,
+    UserDefinedTypeRepresentation, ViewColumnDef,
 };
 pub use self::dml::{CreateIndex, CreateTable, Delete, Insert};
 pub use self::operator::{BinaryOperator, UnaryOperator};
@@ -2691,6 +2692,14 @@ pub enum Statement {
         with_options: Vec<SqlOption>,
     },
     /// ```sql
+    /// ALTER TYPE
+    /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-altertype.html)
+    /// ```
+    AlterType {
+        name: ObjectName,
+        operation: AlterTypeOperation,
+    },
+    /// ```sql
     /// ALTER ROLE
     /// ```
     AlterRole {
@@ -4438,6 +4447,9 @@ impl fmt::Display for Statement {
                 }
                 write!(f, " AS {query}")
             }
+            Statement::AlterType { name, operation } => {
+                write!(f, "ALTER TYPE {name} {operation}")
+            }
             Statement::AlterRole { name, operation } => {
                 write!(f, "ALTER ROLE {name} {operation}")
             }
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -215,6 +215,7 @@ impl Spanned for Values {
 /// - [Statement::CopyIntoSnowflake]
 /// - [Statement::CreateSecret]
 /// - [Statement::CreateRole]
+/// - [Statement::AlterType]
 /// - [Statement::AlterRole]
 /// - [Statement::AttachDatabase]
 /// - [Statement::AttachDuckDBDatabase]
@@ -427,6 +428,7 @@ impl Spanned for Statement {
                     .chain(with_options.iter().map(|i| i.span())),
             ),
             // These statements need to be implemented
+            Statement::AlterType { .. } => Span::empty(),
             Statement::AlterRole { .. } => Span::empty(),
             Statement::AttachDatabase { .. } => Span::empty(),
             Statement::AttachDuckDBDatabase { .. } => Span::empty(),
diff --git a/src/dialect/generic.rs b/src/dialect/generic.rs
@@ -155,4 +155,8 @@ impl Dialect for GenericDialect {
     fn supports_match_against(&self) -> bool {
         true
     }
+
+    fn supports_alter_type(&self) -> bool {
+        true
+    }
 }
diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs
@@ -490,6 +490,16 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Return true if the dialect supports ALTER TYPE statements
+    ///
+    /// Example:
+    /// ```sql
+    /// ALTER TYPE some_enum ADD VALUE 'some_value';
+    /// ```
+    fn supports_alter_type(&self) -> bool {
+        false
+    }
+
     /// Dialect-specific infix parser override
     ///
     /// This method is called to parse the next infix expression.
diff --git a/src/dialect/postgresql.rs b/src/dialect/postgresql.rs
@@ -258,6 +258,10 @@ impl Dialect for PostgreSqlDialect {
     fn supports_array_typedef_size(&self) -> bool {
         true
     }
+
+    fn supports_alter_type(&self) -> bool {
+        true
+    }
 }
 
 pub fn parse_create(parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -8040,16 +8040,21 @@ impl<'a> Parser<'a> {
     }
 
     pub fn parse_alter(&mut self) -> Result<Statement, ParserError> {
-        let object_type = self.expect_one_of_keywords(&[
+        let mut keywords = vec![
             Keyword::VIEW,
             Keyword::TABLE,
             Keyword::INDEX,
             Keyword::ROLE,
             Keyword::POLICY,
             Keyword::CONNECTOR,
-        ])?;
+        ];
+        if self.dialect.supports_alter_type() {
+            keywords.push(Keyword::TYPE);
+        }
+        let object_type = self.expect_one_of_keywords(&keywords)?;
         match object_type {
             Keyword::VIEW => self.parse_alter_view(),
+            Keyword::TYPE => self.parse_alter_type(),
             Keyword::TABLE => {
                 let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
                 let only = self.parse_keyword(Keyword::ONLY); // [ ONLY ]
@@ -8122,6 +8127,55 @@ impl<'a> Parser<'a> {
         })
     }
 
+    pub fn parse_alter_type(&mut self) -> Result<Statement, ParserError> {
+        let name = self.parse_object_name(false)?;
+
+        if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
+            let new_name = self.parse_identifier()?;
+            Ok(Statement::AlterType {
+                name,
+                operation: AlterTypeOperation::Rename { new_name },
+            })
+        } else if self.parse_keywords(&[Keyword::ADD, Keyword::VALUE]) {
+            let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+            let new_enum_value = self.parse_identifier()?;
+            let position = if self.parse_keyword(Keyword::BEFORE) {
+                AlterTypeOperationAddValuePosition::Before(self.parse_identifier()?)
+            } else if self.parse_keyword(Keyword::AFTER) {
+                AlterTypeOperationAddValuePosition::After(self.parse_identifier()?)
+            } else {
+                AlterTypeOperationAddValuePosition::Default
+            };
+
+            Ok(Statement::AlterType {
+                name,
+                operation: AlterTypeOperation::AddValue {
+                    if_not_exists,
+                    value: new_enum_value,
+                    position,
+                },
+            })
+        } else if self.parse_keywords(&[Keyword::RENAME, Keyword::VALUE]) {
+            let existing_enum_value = self.parse_identifier()?;
+            self.expect_keyword(Keyword::TO)?;
+            let new_enum_value = self.parse_identifier()?;
+
+            Ok(Statement::AlterType {
+                name,
+                operation: AlterTypeOperation::RenameValue {
+                    from: existing_enum_value,
+                    to: new_enum_value,
+                },
+            })
+        } else {
+            self.expected_ref(
+                "{RENAME TO | { RENAME | ADD } VALUE}",
+                self.peek_token_ref(),
+            )?;
+            unreachable!()
+        }
+    }
+
     /// Parse a `CALL procedure_name(arg1, arg2, ...)`
     /// or `CALL procedure_name` statement
     pub fn parse_call(&mut self) -> Result<Statement, ParserError> {
diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs
@@ -5320,6 +5320,117 @@ fn parse_create_type_as_enum() {
     }
 }
 
+#[test]
+fn parse_alter_type() {
+    struct TestCase {
+        sql: &'static str,
+        canonical: &'static str,
+        name: &'static str,
+        operation: AlterTypeOperation,
+    }
+    vec![
+        TestCase {
+            sql: r#"ALTER TYPE public.my_type
+                        RENAME TO my_new_type"#,
+            canonical: "ALTER TYPE public.my_type RENAME TO my_new_type",
+            name: "public.my_type",
+            operation: AlterTypeOperation::Rename {
+                new_name: Ident::new("my_new_type"),
+            },
+        },
+        TestCase {
+            sql: r#"ALTER TYPE public.my_type
+                        ADD VALUE IF NOT EXISTS 'label3.5'
+                        BEFORE 'label4'"#,
+            canonical:
+                "ALTER TYPE public.my_type ADD VALUE IF NOT EXISTS 'label3.5' BEFORE 'label4'",
+            name: "public.my_type",
+            operation: AlterTypeOperation::AddValue {
+                if_not_exists: true,
+                value: Ident::with_quote('\'', "label3.5"),
+                position: AlterTypeOperationAddValuePosition::Before(Ident::with_quote(
+                    '\'', "label4",
+                )),
+            },
+        },
+        TestCase {
+            sql: r#"ALTER TYPE public.my_type
+                        ADD VALUE 'label3.5' BEFORE 'label4'"#,
+            canonical: "ALTER TYPE public.my_type ADD VALUE 'label3.5' BEFORE 'label4'",
+            name: "public.my_type",
+            operation: AlterTypeOperation::AddValue {
+                if_not_exists: false,
+                value: Ident::with_quote('\'', "label3.5"),
+                position: AlterTypeOperationAddValuePosition::Before(Ident::with_quote(
+                    '\'', "label4",
+                )),
+            },
+        },
+        TestCase {
+            sql: r#"ALTER TYPE public.my_type
+                        ADD VALUE IF NOT EXISTS 'label3.5'
+                        AFTER 'label3'"#,
+            canonical:
+                "ALTER TYPE public.my_type ADD VALUE IF NOT EXISTS 'label3.5' AFTER 'label3'",
+            name: "public.my_type",
+            operation: AlterTypeOperation::AddValue {
+                if_not_exists: true,
+                value: Ident::with_quote('\'', "label3.5"),
+                position: AlterTypeOperationAddValuePosition::After(Ident::with_quote(
+                    '\'', "label3",
+                )),
+            },
+        },
+        TestCase {
+            sql: r#"ALTER TYPE public.my_type
+                        ADD VALUE 'label3.5'
+                        AFTER 'label3'"#,
+            canonical: "ALTER TYPE public.my_type ADD VALUE 'label3.5' AFTER 'label3'",
+            name: "public.my_type",
+            operation: AlterTypeOperation::AddValue {
+                if_not_exists: false,
+                value: Ident::with_quote('\'', "label3.5"),
+                position: AlterTypeOperationAddValuePosition::After(Ident::with_quote(
+                    '\'', "label3",
+                )),
+            },
+        },
+        TestCase {
+            sql: r#"ALTER TYPE public.my_type
+                        ADD VALUE IF NOT EXISTS 'label5'"#,
+            canonical: "ALTER TYPE public.my_type ADD VALUE IF NOT EXISTS 'label5'",
+            name: "public.my_type",
+            operation: AlterTypeOperation::AddValue {
+                if_not_exists: true,
+                value: Ident::with_quote('\'', "label5"),
+                position: AlterTypeOperationAddValuePosition::Default,
+            },
+        },
+        TestCase {
+            sql: r#"ALTER TYPE public.my_type
+                        ADD VALUE 'label5'"#,
+            canonical: "ALTER TYPE public.my_type ADD VALUE 'label5'",
+            name: "public.my_type",
+            operation: AlterTypeOperation::AddValue {
+                if_not_exists: false,
+                value: Ident::with_quote('\'', "label5"),
+                position: AlterTypeOperationAddValuePosition::Default,
+            },
+        },
+    ]
+    .into_iter()
+    .enumerate()
+    .for_each(|(index, tc)| {
+        let statement = pg_and_generic().one_statement_parses_to(tc.sql, tc.canonical);
+        if let Statement::AlterType { name, operation } = statement {
+            assert_eq!(tc.name, name.to_string(), "TestCase[{index}].name");
+            assert_eq!(tc.operation, operation, "TestCase[{index}].operation");
+        } else {
+            unreachable!("{:?} should parse to Statement::AlterType", tc.canonical);
+        }
+    });
+}
+
 #[test]
 fn parse_bitstring_literal() {
     let select = pg_and_generic().verified_only_select("SELECT B'111'");

Original file line number	Diff line number	Diff line change
`@@ -155,4 +155,8 @@ impl Dialect for GenericDialect {`
`155`	`155`	`fn supports_match_against(&self) -> bool {`
`156`	`156`	`true`
`157`	`157`	`}`
	`158`	`+`
	`159`	`+ fn supports_alter_type(&self) -> bool {`
	`160`	`+ true`
	`161`	`+ }`
`158`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,6 +258,10 @@ impl Dialect for PostgreSqlDialect {`
`258`	`258`	`fn supports_array_typedef_size(&self) -> bool {`
`259`	`259`	`true`
`260`	`260`	`}`
	`261`	`+`
	`262`	`+ fn supports_alter_type(&self) -> bool {`
	`263`	`+ true`
	`264`	`+ }`
`261`	`265`	`}`
`262`	`266`
`263`	`267`	`pub fn parse_create(parser: &mut Parser) -> Option<Result<Statement, ParserError>> {`