feat(parser): parse PostgreSQL collation DDL

Extend parser dispatch and handlers for PostgreSQL collation syntax.\n\n- parse CREATE COLLATION with FROM and option-list forms\n- parse ALTER COLLATION operations: RENAME TO, OWNER TO, SET SCHEMA, REFRESH VERSION\n- accept DROP COLLATION via generic DROP statement path\n- support COMMENT ON COLLATION targets

Author: LucaCappelletti94

src/parser/mod.rs

@@ -898,6 +898,9 @@ impl<'a> Parser<'a> {
         let token = self.next_token();
 
         let (object_type, object_name) = match token.token {
+            Token::Word(w) if w.keyword == Keyword::COLLATION => {
+                (CommentObject::Collation, self.parse_object_name(false)?)
+            }
             Token::Word(w) if w.keyword == Keyword::COLUMN => {
                 (CommentObject::Column, self.parse_object_name(false)?)
             }
@@ -5151,6 +5154,8 @@ impl<'a> Parser<'a> {
             self.parse_create_role().map(Into::into)
         } else if self.parse_keyword(Keyword::SEQUENCE) {
             self.parse_create_sequence(temporary)
+        } else if self.parse_keyword(Keyword::COLLATION) {
+            self.parse_create_collation().map(Into::into)
         } else if self.parse_keyword(Keyword::TYPE) {
             self.parse_create_type()
         } else if self.parse_keyword(Keyword::PROCEDURE) {
@@ -7200,6 +7205,8 @@ impl<'a> Parser<'a> {
 
         let object_type = if self.parse_keyword(Keyword::TABLE) {
             ObjectType::Table
+        } else if self.parse_keyword(Keyword::COLLATION) {
+            ObjectType::Collation
         } else if self.parse_keyword(Keyword::VIEW) {
             ObjectType::View
         } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEW]) {
@@ -7249,7 +7256,7 @@ impl<'a> Parser<'a> {
             };
         } else {
             return self.expected_ref(
-                "CONNECTOR, DATABASE, EXTENSION, FUNCTION, INDEX, OPERATOR, POLICY, PROCEDURE, ROLE, SCHEMA, SECRET, SEQUENCE, STAGE, TABLE, TRIGGER, TYPE, VIEW, MATERIALIZED VIEW or USER after DROP",
+                "COLLATION, CONNECTOR, DATABASE, EXTENSION, FUNCTION, INDEX, OPERATOR, POLICY, PROCEDURE, ROLE, SCHEMA, SECRET, SEQUENCE, STAGE, TABLE, TRIGGER, TYPE, VIEW, MATERIALIZED VIEW or USER after DROP",
                 self.peek_token_ref(),
             );
         };
@@ -7990,6 +7997,31 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Parse a PostgreSQL-specific [Statement::CreateCollation] statement.
+    pub fn parse_create_collation(&mut self) -> Result<CreateCollation, ParserError> {
+        let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+        let name = self.parse_object_name(false)?;
+
+        let definition = if self.parse_keyword(Keyword::FROM) {
+            CreateCollationDefinition::From(self.parse_object_name(false)?)
+        } else if self.consume_token(&Token::LParen) {
+            let options = self.parse_comma_separated(Parser::parse_sql_option)?;
+            self.expect_token(&Token::RParen)?;
+            CreateCollationDefinition::Options(options)
+        } else {
+            return self.expected_ref(
+                "FROM or parenthesized option list after CREATE COLLATION name",
+                self.peek_token_ref(),
+            );
+        };
+
+        Ok(CreateCollation {
+            if_not_exists,
+            name,
+            definition,
+        })
+    }
+
     /// Parse a PostgreSQL-specific [Statement::DropExtension] statement.
     pub fn parse_drop_extension(&mut self) -> Result<Statement, ParserError> {
         let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
@@ -10431,6 +10463,7 @@ impl<'a> Parser<'a> {
         let object_type = self.expect_one_of_keywords(&[
             Keyword::VIEW,
             Keyword::TYPE,
+            Keyword::COLLATION,
             Keyword::TABLE,
             Keyword::INDEX,
             Keyword::ROLE,
@@ -10449,6 +10482,7 @@ impl<'a> Parser<'a> {
             }
             Keyword::VIEW => self.parse_alter_view(),
             Keyword::TYPE => self.parse_alter_type(),
+            Keyword::COLLATION => self.parse_alter_collation().map(Into::into),
             Keyword::TABLE => self.parse_alter_table(false),
             Keyword::ICEBERG => {
                 self.expect_keyword(Keyword::TABLE)?;
@@ -10487,7 +10521,7 @@ impl<'a> Parser<'a> {
             Keyword::USER => self.parse_alter_user().map(Into::into),
             // unreachable because expect_one_of_keywords used above
             unexpected_keyword => Err(ParserError::ParserError(
-                format!("Internal parser error: expected any of {{VIEW, TYPE, TABLE, INDEX, ROLE, POLICY, CONNECTOR, ICEBERG, SCHEMA, USER, OPERATOR}}, got {unexpected_keyword:?}"),
+                format!("Internal parser error: expected any of {{VIEW, TYPE, COLLATION, TABLE, INDEX, ROLE, POLICY, CONNECTOR, ICEBERG, SCHEMA, USER, OPERATOR}}, got {unexpected_keyword:?}"),
             )),
         }
     }
@@ -10603,6 +10637,33 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse a [Statement::AlterCollation].
+    ///
+    /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-altercollation.html)
+    pub fn parse_alter_collation(&mut self) -> Result<AlterCollation, ParserError> {
+        let name = self.parse_object_name(false)?;
+        let operation = if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
+            AlterCollationOperation::RenameTo {
+                new_name: self.parse_identifier()?,
+            }
+        } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
+            AlterCollationOperation::OwnerTo(self.parse_owner()?)
+        } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) {
+            AlterCollationOperation::SetSchema {
+                schema_name: self.parse_object_name(false)?,
+            }
+        } else if self.parse_keywords(&[Keyword::REFRESH, Keyword::VERSION]) {
+            AlterCollationOperation::RefreshVersion
+        } else {
+            return self.expected_ref(
+                "RENAME TO, OWNER TO, SET SCHEMA, or REFRESH VERSION after ALTER COLLATION",
+                self.peek_token_ref(),
+            );
+        };
+
+        Ok(AlterCollation { name, operation })
+    }
+
     /// Parse a [Statement::AlterOperator]
     ///
     /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-alteroperator.html)