Added more missing From impls and cleaned code

LucaCappelletti94 · LucaCappelletti94 · commit 7c99351e1328 · 2026-01-10T14:40:38.000+01:00
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -11774,6 +11774,24 @@ impl From<CreateConnector> for Statement {
     }
 }
 
+impl From<CreateOperator> for Statement {
+    fn from(c: CreateOperator) -> Self {
+        Self::CreateOperator(c)
+    }
+}
+
+impl From<CreateOperatorFamily> for Statement {
+    fn from(c: CreateOperatorFamily) -> Self {
+        Self::CreateOperatorFamily(c)
+    }
+}
+
+impl From<CreateOperatorClass> for Statement {
+    fn from(c: CreateOperatorClass) -> Self {
+        Self::CreateOperatorClass(c)
+    }
+}
+
 impl From<AlterSchema> for Statement {
     fn from(a: AlterSchema) -> Self {
         Self::AlterSchema(a)
@@ -11786,6 +11804,36 @@ impl From<AlterType> for Statement {
     }
 }
 
+impl From<AlterOperator> for Statement {
+    fn from(a: AlterOperator) -> Self {
+        Self::AlterOperator(a)
+    }
+}
+
+impl From<AlterOperatorFamily> for Statement {
+    fn from(a: AlterOperatorFamily) -> Self {
+        Self::AlterOperatorFamily(a)
+    }
+}
+
+impl From<AlterOperatorClass> for Statement {
+    fn from(a: AlterOperatorClass) -> Self {
+        Self::AlterOperatorClass(a)
+    }
+}
+
+impl From<Merge> for Statement {
+    fn from(m: Merge) -> Self {
+        Self::Merge(m)
+    }
+}
+
+impl From<AlterUser> for Statement {
+    fn from(a: AlterUser) -> Self {
+        Self::AlterUser(a)
+    }
+}
+
 impl From<DropDomain> for Statement {
     fn from(d: DropDomain) -> Self {
         Self::DropDomain(d)
diff --git a/src/parser/alter.rs b/src/parser/alter.rs
@@ -148,7 +148,7 @@ impl Parser<'_> {
     /// ```sql
     /// ALTER USER [ IF EXISTS ] [ <name> ] [ OPTIONS ]
     /// ```
-    pub fn parse_alter_user(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_alter_user(&mut self) -> Result<AlterUser, ParserError> {
         let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
         let name = self.parse_identifier()?;
         let _ = self.parse_keyword(Keyword::WITH);
@@ -309,7 +309,7 @@ impl Parser<'_> {
             None
         };
 
-        Ok(Statement::AlterUser(AlterUser {
+        Ok(AlterUser {
             if_exists,
             name,
             rename_to,
@@ -329,7 +329,7 @@ impl Parser<'_> {
             set_props,
             unset_props,
             password,
-        }))
+        })
     }
 
     fn parse_mfa_method(&mut self) -> Result<MfaMethodKind, ParserError> {
diff --git a/src/parser/merge.rs b/src/parser/merge.rs
@@ -18,7 +18,7 @@ use alloc::{boxed::Box, format, vec, vec::Vec};
 use crate::{
     ast::{
         Merge, MergeAction, MergeClause, MergeClauseKind, MergeInsertExpr, MergeInsertKind,
-        MergeUpdateExpr, ObjectName, OutputClause, SetExpr, Statement,
+        MergeUpdateExpr, ObjectName, OutputClause, SetExpr,
     },
     dialect::{BigQueryDialect, GenericDialect, MySqlDialect},
     keywords::Keyword,
@@ -36,11 +36,13 @@ impl Parser<'_> {
         &mut self,
         merge_token: TokenWithSpan,
     ) -> Result<Box<SetExpr>, ParserError> {
-        Ok(Box::new(SetExpr::Merge(self.parse_merge(merge_token)?)))
+        Ok(Box::new(SetExpr::Merge(
+            self.parse_merge(merge_token)?.into(),
+        )))
     }
 
     /// Parse a `MERGE` statement
-    pub fn parse_merge(&mut self, merge_token: TokenWithSpan) -> Result<Statement, ParserError> {
+    pub fn parse_merge(&mut self, merge_token: TokenWithSpan) -> Result<Merge, ParserError> {
         let into = self.parse_keyword(Keyword::INTO);
 
         let table = self.parse_table_factor()?;
@@ -55,15 +57,15 @@ impl Parser<'_> {
             None => None,
         };
 
-        Ok(Statement::Merge(Merge {
+        Ok(Merge {
             merge_token: merge_token.into(),
             into,
             table,
             source,
             on: Box::new(on),
             clauses,
             output,
-        }))
+        })
     }
 
     fn parse_merge_clauses(&mut self) -> Result<Vec<MergeClause>, ParserError> {
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -607,19 +607,19 @@ impl<'a> Parser<'a> {
                 Keyword::ANALYZE => self.parse_analyze(),
                 Keyword::CASE => {
                     self.prev_token();
-                    self.parse_case_stmt()
+                    self.parse_case_stmt().map(Into::into)
                 }
                 Keyword::IF => {
                     self.prev_token();
-                    self.parse_if_stmt()
+                    self.parse_if_stmt().map(Into::into)
                 }
                 Keyword::WHILE => {
                     self.prev_token();
-                    self.parse_while()
+                    self.parse_while().map(Into::into)
                 }
                 Keyword::RAISE => {
                     self.prev_token();
-                    self.parse_raise_stmt()
+                    self.parse_raise_stmt().map(Into::into)
                 }
                 Keyword::SELECT | Keyword::WITH | Keyword::VALUES | Keyword::FROM => {
                     self.prev_token();
@@ -679,7 +679,7 @@ impl<'a> Parser<'a> {
                 Keyword::DEALLOCATE => self.parse_deallocate(),
                 Keyword::EXECUTE | Keyword::EXEC => self.parse_execute(),
                 Keyword::PREPARE => self.parse_prepare(),
-                Keyword::MERGE => self.parse_merge(next_token),
+                Keyword::MERGE => self.parse_merge(next_token).map(Into::into),
                 // `LISTEN`, `UNLISTEN` and `NOTIFY` are Postgres-specific
                 // syntaxes. They are used for Postgres statement.
                 Keyword::LISTEN if self.dialect.supports_listen_notify() => self.parse_listen(),
@@ -727,7 +727,7 @@ impl<'a> Parser<'a> {
     /// Parse a `CASE` statement.
     ///
     /// See [Statement::Case]
-    pub fn parse_case_stmt(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_case_stmt(&mut self) -> Result<CaseStatement, ParserError> {
         let case_token = self.expect_keyword(Keyword::CASE)?;
 
         let match_expr = if self.peek_keyword(Keyword::WHEN) {
@@ -752,19 +752,19 @@ impl<'a> Parser<'a> {
             end_case_token = self.expect_keyword(Keyword::CASE)?;
         }
 
-        Ok(Statement::Case(CaseStatement {
+        Ok(CaseStatement {
             case_token: AttachedToken(case_token),
             match_expr,
             when_blocks,
             else_block,
             end_case_token: AttachedToken(end_case_token),
-        }))
+        })
     }
 
     /// Parse an `IF` statement.
     ///
     /// See [Statement::If]
-    pub fn parse_if_stmt(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_if_stmt(&mut self) -> Result<IfStatement, ParserError> {
         self.expect_keyword_is(Keyword::IF)?;
         let if_block = self.parse_conditional_statement_block(&[
             Keyword::ELSE,
@@ -793,22 +793,22 @@ impl<'a> Parser<'a> {
         self.expect_keyword_is(Keyword::END)?;
         let end_token = self.expect_keyword(Keyword::IF)?;
 
-        Ok(Statement::If(IfStatement {
+        Ok(IfStatement {
             if_block,
             elseif_blocks,
             else_block,
             end_token: Some(AttachedToken(end_token)),
-        }))
+        })
     }
 
     /// Parse a `WHILE` statement.
     ///
     /// See [Statement::While]
-    fn parse_while(&mut self) -> Result<Statement, ParserError> {
+    fn parse_while(&mut self) -> Result<WhileStatement, ParserError> {
         self.expect_keyword_is(Keyword::WHILE)?;
         let while_block = self.parse_conditional_statement_block(&[Keyword::END])?;
 
-        Ok(Statement::While(WhileStatement { while_block }))
+        Ok(WhileStatement { while_block })
     }
 
     /// Parses an expression and associated list of statements
@@ -875,7 +875,7 @@ impl<'a> Parser<'a> {
     /// Parse a `RAISE` statement.
     ///
     /// See [Statement::Raise]
-    pub fn parse_raise_stmt(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_raise_stmt(&mut self) -> Result<RaiseStatement, ParserError> {
         self.expect_keyword_is(Keyword::RAISE)?;
 
         let value = if self.parse_keywords(&[Keyword::USING, Keyword::MESSAGE]) {
@@ -885,7 +885,7 @@ impl<'a> Parser<'a> {
             self.maybe_parse(|parser| parser.parse_expr().map(RaiseStatementValue::Expr))?
         };
 
-        Ok(Statement::Raise(RaiseStatement { value }))
+        Ok(RaiseStatement { value })
     }
     /// Parse a COMMENT statement.
     ///
@@ -1432,7 +1432,7 @@ impl<'a> Parser<'a> {
 
                 Ok(RenameTable { old_name, new_name })
             })?;
-            Ok(Statement::RenameTable(rename_tables))
+            Ok(rename_tables.into())
         } else {
             self.expected("KEYWORD `TABLE` after RENAME", self.peek_token())
         }
@@ -4898,7 +4898,7 @@ impl<'a> Parser<'a> {
         } else if self.parse_keyword(Keyword::SECRET) {
             self.parse_create_secret(or_replace, temporary, persistent)
         } else if self.parse_keyword(Keyword::USER) {
-            self.parse_create_user(or_replace)
+            self.parse_create_user(or_replace).map(Into::into)
         } else if or_replace {
             self.expected(
                 "[EXTERNAL] TABLE or [MATERIALIZED] VIEW or FUNCTION after CREATE OR REPLACE",
@@ -4942,7 +4942,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn parse_create_user(&mut self, or_replace: bool) -> Result<Statement, ParserError> {
+    fn parse_create_user(&mut self, or_replace: bool) -> Result<CreateUser, ParserError> {
         let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
         let name = self.parse_identifier()?;
         let options = self
@@ -4954,7 +4954,7 @@ impl<'a> Parser<'a> {
         } else {
             vec![]
         };
-        Ok(Statement::CreateUser(CreateUser {
+        Ok(CreateUser {
             or_replace,
             if_not_exists,
             name,
@@ -4967,7 +4967,7 @@ impl<'a> Parser<'a> {
                 options: tags,
                 delimiter: KeyValueOptionsDelimiter::Comma,
             },
-        }))
+        })
     }
 
     /// See [DuckDB Docs](https://duckdb.org/docs/sql/statements/create_secret.html) for more details.
@@ -10158,17 +10158,17 @@ impl<'a> Parser<'a> {
             }
             Keyword::OPERATOR => {
                 if self.parse_keyword(Keyword::FAMILY) {
-                    self.parse_alter_operator_family()
+                    self.parse_alter_operator_family().map(Into::into)
                 } else if self.parse_keyword(Keyword::CLASS) {
-                    self.parse_alter_operator_class()
+                    self.parse_alter_operator_class().map(Into::into)
                 } else {
-                    self.parse_alter_operator()
+                    self.parse_alter_operator().map(Into::into)
                 }
             }
             Keyword::ROLE => self.parse_alter_role(),
             Keyword::POLICY => self.parse_alter_policy(),
             Keyword::CONNECTOR => self.parse_alter_connector(),
-            Keyword::USER => self.parse_alter_user(),
+            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:?}"),
@@ -10290,7 +10290,7 @@ impl<'a> Parser<'a> {
     /// Parse a [Statement::AlterOperator]
     ///
     /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-alteroperator.html)
-    pub fn parse_alter_operator(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_alter_operator(&mut self) -> Result<AlterOperator, ParserError> {
         let name = self.parse_operator_name()?;
 
         // Parse (left_type, right_type)
@@ -10389,12 +10389,12 @@ impl<'a> Parser<'a> {
             );
         };
 
-        Ok(Statement::AlterOperator(AlterOperator {
+        Ok(AlterOperator {
             name,
             left_type,
             right_type,
             operation,
-        }))
+        })
     }
 
     /// Parse an operator item for ALTER OPERATOR FAMILY ADD operations
@@ -10527,7 +10527,7 @@ impl<'a> Parser<'a> {
 
     /// Parse a [Statement::AlterOperatorFamily]
     /// See <https://www.postgresql.org/docs/current/sql-alteropfamily.html>
-    pub fn parse_alter_operator_family(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_alter_operator_family(&mut self) -> Result<AlterOperatorFamily, ParserError> {
         let name = self.parse_object_name(false)?;
         self.expect_keyword(Keyword::USING)?;
         let using = self.parse_identifier()?;
@@ -10554,17 +10554,17 @@ impl<'a> Parser<'a> {
             );
         };
 
-        Ok(Statement::AlterOperatorFamily(AlterOperatorFamily {
+        Ok(AlterOperatorFamily {
             name,
             using,
             operation,
-        }))
+        })
     }
 
     /// Parse an `ALTER OPERATOR CLASS` statement.
     ///
     /// Handles operations like `RENAME TO`, `OWNER TO`, and `SET SCHEMA`.
-    pub fn parse_alter_operator_class(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_alter_operator_class(&mut self) -> Result<AlterOperatorClass, ParserError> {
         let name = self.parse_object_name(false)?;
         self.expect_keyword(Keyword::USING)?;
         let using = self.parse_identifier()?;
@@ -10585,11 +10585,11 @@ impl<'a> Parser<'a> {
             );
         };
 
-        Ok(Statement::AlterOperatorClass(AlterOperatorClass {
+        Ok(AlterOperatorClass {
             name,
             using,
             operation,
-        }))
+        })
     }
 
     /// Parse an `ALTER SCHEMA` statement.
@@ -16803,7 +16803,7 @@ impl<'a> Parser<'a> {
                 None
             };
 
-            Ok(Statement::Insert(Insert {
+            Ok(Insert {
                 insert_token: insert_token.into(),
                 or,
                 table: table_object,
@@ -16824,7 +16824,8 @@ impl<'a> Parser<'a> {
                 insert_alias,
                 settings,
                 format_clause,
-            }))
+            }
+            .into())
         }
     }
 
