Merge pull request #3 from finchxxia/feature/snowflake-multi-table-insert-v2

finchxxia · web-flow · commit 41e8bb7b911f · 2026-01-26T20:40:32.000+08:00
[Chore] use multi table insert type in struct
diff --git a/src/ast/dml.rs b/src/ast/dml.rs
@@ -90,13 +90,14 @@ pub struct Insert {
     ///
     /// [ClickHouse formats JSON insert](https://clickhouse.com/docs/en/interfaces/formats#json-inserting-data)
     pub format_clause: Option<InputFormatClause>,
-    /// For multi-table insert: `INSERT FIRST` vs `INSERT ALL`
+    /// For Snowflake multi-table insert: specifies the type (`ALL` or `FIRST`)
     ///
-    /// When `true`, this is an `INSERT FIRST` statement (only the first matching WHEN clause is executed).
-    /// When `false` with non-empty `clauses`, this is an `INSERT ALL` statement.
+    /// - `None` means this is a regular single-table INSERT
+    /// - `Some(All)` means `INSERT ALL` (all matching WHEN clauses are executed)
+    /// - `Some(First)` means `INSERT FIRST` (only the first matching WHEN clause is executed)
     ///
     /// See: <https://docs.snowflake.com/en/sql-reference/sql/insert-multi-table>
-    pub insert_first: bool,
+    pub multi_table_insert_type: Option<MultiTableInsertType>,
     /// For multi-table insert: additional INTO clauses (unconditional)
     ///
     /// Used for `INSERT ALL INTO t1 INTO t2 ... SELECT ...`
@@ -117,9 +118,7 @@ pub struct Insert {
 
 impl Display for Insert {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Check if this is a Snowflake multi-table insert
-        let is_multi_table = !self.multi_table_into_clauses.is_empty()
-            || !self.multi_table_when_clauses.is_empty();
+        let is_multi_table = self.multi_table_insert_type.is_some();
 
         // SQLite OR conflict has a special format: INSERT OR ... INTO table_name
         if let Some(on_conflict) = self.or {
@@ -148,8 +147,8 @@ impl Display for Insert {
                 write!(f, " OVERWRITE")?;
             }
 
-            if is_multi_table {
-                write!(f, " {}", if self.insert_first { "FIRST" } else { "ALL" })?;
+            if let Some(insert_type) = &self.multi_table_insert_type {
+                write!(f, " {}", insert_type)?;
             }
 
             if self.into {
@@ -815,3 +814,25 @@ impl Display for MultiTableInsertValue {
         }
     }
 }
+
+/// The type of multi-table INSERT statement(Snowflake).
+///
+/// See: <https://docs.snowflake.com/en/sql-reference/sql/insert-multi-table>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum MultiTableInsertType {
+    /// `INSERT ALL` - all matching WHEN clauses are executed
+    All,
+    /// `INSERT FIRST` - only the first matching WHEN clause is executed
+    First,
+}
+
+impl Display for MultiTableInsertType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            MultiTableInsertType::All => write!(f, "ALL"),
+            MultiTableInsertType::First => write!(f, "FIRST"),
+        }
+    }
+}
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -81,8 +81,8 @@ pub use self::ddl::{
 };
 pub use self::dml::{
     Delete, Insert, Merge, MergeAction, MergeClause, MergeClauseKind, MergeInsertExpr,
-    MergeInsertKind, MergeUpdateExpr, MultiTableInsertIntoClause, MultiTableInsertValue,
-    MultiTableInsertValues, MultiTableInsertWhenClause, OutputClause, Update,
+    MergeInsertKind, MergeUpdateExpr, MultiTableInsertIntoClause, MultiTableInsertType,
+    MultiTableInsertValue, MultiTableInsertValues, MultiTableInsertWhenClause, OutputClause, Update,
 };
 pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -1306,7 +1306,7 @@ impl Spanned for Insert {
             assignments,
             settings: _,      // todo, clickhouse specific
             format_clause: _, // todo, clickhouse specific
-            insert_first: _,             // snowflake multi-table insert
+            multi_table_insert_type: _,  // snowflake multi-table insert
             multi_table_into_clauses: _, // snowflake multi-table insert
             multi_table_when_clauses: _, // snowflake multi-table insert
             multi_table_else_clause: _,  // snowflake multi-table insert
diff --git a/src/dialect/snowflake.rs b/src/dialect/snowflake.rs
@@ -31,8 +31,8 @@ use crate::ast::{
     ColumnPolicy, ColumnPolicyProperty, ContactEntry, CopyIntoSnowflakeKind, CreateTableLikeKind,
     DollarQuotedString, Ident, IdentityParameters, IdentityProperty, IdentityPropertyFormatKind,
     IdentityPropertyKind, IdentityPropertyOrder, InitializeKind, Insert, MultiTableInsertIntoClause,
-    MultiTableInsertValue, MultiTableInsertValues, MultiTableInsertWhenClause, ObjectName,
-    ObjectNamePart, RefreshModeKind, RowAccessPolicy, ShowObjects, SqlOption, Statement,
+    MultiTableInsertType, MultiTableInsertValue, MultiTableInsertValues, MultiTableInsertWhenClause,
+    ObjectName, ObjectNamePart, RefreshModeKind, RowAccessPolicy, ShowObjects, SqlOption, Statement,
     StorageSerializationPolicy, TableObject, TagsColumnOption, Value, WrappedCollection,
 };
 use crate::tokenizer::TokenWithSpan;
@@ -328,12 +328,15 @@ impl Dialect for SnowflakeDialect {
 
             // Check for ALL or FIRST keyword
             if let Some(kw) = parser.parse_one_of_keywords(&[Keyword::ALL, Keyword::FIRST]) {
-                let insert_first = kw == Keyword::FIRST;
+                let multi_table_insert_type = match kw {
+                    Keyword::FIRST => MultiTableInsertType::First,
+                    _ => MultiTableInsertType::All,
+                };
                 return Some(parse_multi_table_insert(
                     parser,
                     insert_token,
                     overwrite,
-                    insert_first,
+                    multi_table_insert_type,
                 ));
             }
 
@@ -1677,7 +1680,7 @@ fn parse_multi_table_insert(
     parser: &mut Parser,
     insert_token: TokenWithSpan,
     overwrite: bool,
-    insert_first: bool,
+    multi_table_insert_type: MultiTableInsertType,
 ) -> Result<Statement, ParserError> {
     // Check if this is conditional (has WHEN clauses) or unconditional (direct INTO clauses)
     let is_conditional = parser.peek_keyword(Keyword::WHEN);
@@ -1717,7 +1720,7 @@ fn parse_multi_table_insert(
         insert_alias: None,
         settings: None,
         format_clause: None,
-        insert_first,
+        multi_table_insert_type: Some(multi_table_insert_type),
         multi_table_into_clauses,
         multi_table_when_clauses,
         multi_table_else_clause,
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -16618,7 +16618,7 @@ impl<'a> Parser<'a> {
                 insert_alias,
                 settings,
                 format_clause,
-                insert_first: false,
+                multi_table_insert_type: None,
                 multi_table_into_clauses: vec![],
                 multi_table_when_clauses: vec![],
                 multi_table_else_clause: None,
diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs
@@ -5370,7 +5370,7 @@ fn test_simple_postgres_insert_with_alias() {
             insert_alias: None,
             settings: None,
             format_clause: None,
-            insert_first: false,
+            multi_table_insert_type: None,
             multi_table_into_clauses: vec![],
             multi_table_when_clauses: vec![],
             multi_table_else_clause: None,
@@ -5448,7 +5448,7 @@ fn test_simple_postgres_insert_with_alias() {
             insert_alias: None,
             settings: None,
             format_clause: None,
-            insert_first: false,
+            multi_table_insert_type: None,
             multi_table_into_clauses: vec![],
             multi_table_when_clauses: vec![],
             multi_table_else_clause: None,
@@ -5524,7 +5524,7 @@ fn test_simple_insert_with_quoted_alias() {
             insert_alias: None,
             settings: None,
             format_clause: None,
-            insert_first: false,
+            multi_table_insert_type: None,
             multi_table_into_clauses: vec![],
             multi_table_when_clauses: vec![],
             multi_table_else_clause: None,
diff --git a/tests/sqlparser_snowflake.rs b/tests/sqlparser_snowflake.rs
@@ -3616,7 +3616,7 @@ fn test_multi_table_insert_ast_unconditional() {
 
     match stmt {
         Statement::Insert(Insert {
-            insert_first,
+            multi_table_insert_type,
             overwrite,
             multi_table_into_clauses,
             multi_table_when_clauses,
@@ -3625,7 +3625,7 @@ fn test_multi_table_insert_ast_unconditional() {
             ..
         }) => {
             // Should be INSERT ALL (not FIRST)
-            assert!(!insert_first);
+            assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::All));
             assert!(!overwrite);
 
             // Should have 2 INTO clauses
@@ -3709,14 +3709,14 @@ fn test_multi_table_insert_ast_conditional() {
 
     match stmt {
         Statement::Insert(Insert {
-            insert_first,
+            multi_table_insert_type,
             multi_table_into_clauses,
             multi_table_when_clauses,
             multi_table_else_clause,
             ..
         }) => {
             // Should be INSERT ALL (not FIRST)
-            assert!(!insert_first);
+            assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::All));
 
             // Unconditional INTO clauses should be empty for conditional insert
             assert!(multi_table_into_clauses.is_empty());
@@ -3752,12 +3752,12 @@ fn test_multi_table_insert_ast_first() {
 
     match stmt {
         Statement::Insert(Insert {
-            insert_first,
+            multi_table_insert_type,
             multi_table_when_clauses,
             ..
         }) => {
             // Should be INSERT FIRST
-            assert!(insert_first);
+            assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::First));
             assert_eq!(multi_table_when_clauses.len(), 2);
         }
         _ => panic!("Expected INSERT statement"),
@@ -3773,12 +3773,12 @@ fn test_multi_table_insert_ast_overwrite() {
     match stmt {
         Statement::Insert(Insert {
             overwrite,
-            insert_first,
+            multi_table_insert_type,
             multi_table_into_clauses,
             ..
         }) => {
             assert!(overwrite);
-            assert!(!insert_first);
+            assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::All));
             assert_eq!(multi_table_into_clauses.len(), 2);
         }
         _ => panic!("Expected INSERT statement"),
