You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by gi...@apache.org on 2025/11/22 14:55:28 UTC

(datafusion-sqlparser-rs) branch gh-readonly-queue/main/pr-2100-1114d6a2bcfc6f3cdb3f2f195278d075e669faf4 created (now 2b8e99c6)

This is an automated email from the ASF dual-hosted git repository.

github-bot pushed a change to branch gh-readonly-queue/main/pr-2100-1114d6a2bcfc6f3cdb3f2f195278d075e669faf4
in repository https://gitbox.apache.org/repos/asf/datafusion-sqlparser-rs.git


      at 2b8e99c6 impl `Spanned` for MERGE statements (#2100)

This branch includes the following new commits:

     new 2b8e99c6 impl `Spanned` for MERGE statements (#2100)

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org


(datafusion-sqlparser-rs) 01/01: impl `Spanned` for MERGE statements (#2100)

Posted by gi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

github-bot pushed a commit to branch gh-readonly-queue/main/pr-2100-1114d6a2bcfc6f3cdb3f2f195278d075e669faf4
in repository https://gitbox.apache.org/repos/asf/datafusion-sqlparser-rs.git

commit 2b8e99c6652bb0870a6ae495a22732d860e7d53d
Author: xitep <xi...@users.noreply.github.com>
AuthorDate: Sat Nov 22 15:55:08 2025 +0100

    impl `Spanned` for MERGE statements (#2100)
---
 src/ast/mod.rs              |  34 ++++-
 src/ast/spans.rs            | 295 ++++++++++++++++++++++++++++++++++++++++++--
 src/parser/mod.rs           |  85 +++++++++----
 tests/sqlparser_bigquery.rs |  41 +++++-
 tests/sqlparser_common.rs   |  10 +-
 5 files changed, 418 insertions(+), 47 deletions(-)

diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index 482c3813..2c452a69 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -4064,6 +4064,8 @@ pub enum Statement {
     /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement)
     /// [MSSQL](https://learn.microsoft.com/en-us/sql/t-sql/statements/merge-transact-sql?view=sql-server-ver16)
     Merge {
+        /// The `MERGE` token that starts the statement.
+        merge_token: AttachedToken,
         /// optional INTO keyword
         into: bool,
         /// Specifies the table to merge
@@ -4088,7 +4090,6 @@ pub enum Statement {
         /// Table flag
         table_flag: Option<ObjectName>,
         /// Table name
-
         #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
         table_name: ObjectName,
         has_as: bool,
@@ -5488,6 +5489,7 @@ impl fmt::Display for Statement {
                 write!(f, "RELEASE SAVEPOINT {name}")
             }
             Statement::Merge {
+                merge_token: _,
                 into,
                 table,
                 source,
@@ -8620,6 +8622,8 @@ impl Display for MergeInsertKind {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct MergeInsertExpr {
+    /// The `INSERT` token that starts the sub-expression.
+    pub insert_token: AttachedToken,
     /// Columns (if any) specified by the insert.
     ///
     /// Example:
@@ -8628,6 +8632,8 @@ pub struct MergeInsertExpr {
     /// INSERT (product, quantity) ROW
     /// ```
     pub columns: Vec<Ident>,
+    /// The token, `[VALUES | ROW]` starting `kind`.
+    pub kind_token: AttachedToken,
     /// The insert type used by the statement.
     pub kind: MergeInsertKind,
 }
@@ -8667,9 +8673,16 @@ pub enum MergeAction {
     /// ```sql
     /// UPDATE SET quantity = T.quantity + S.quantity
     /// ```
-    Update { assignments: Vec<Assignment> },
+    Update {
+        /// The `UPDATE` token that starts the sub-expression.
+        update_token: AttachedToken,
+        assignments: Vec<Assignment>,
+    },
     /// A plain `DELETE` clause
-    Delete,
+    Delete {
+        /// The `DELETE` token that starts the sub-expression.
+        delete_token: AttachedToken,
+    },
 }
 
 impl Display for MergeAction {
@@ -8678,10 +8691,10 @@ impl Display for MergeAction {
             MergeAction::Insert(insert) => {
                 write!(f, "INSERT {insert}")
             }
-            MergeAction::Update { assignments } => {
+            MergeAction::Update { assignments, .. } => {
                 write!(f, "UPDATE SET {}", display_comma_separated(assignments))
             }
-            MergeAction::Delete => {
+            MergeAction::Delete { .. } => {
                 write!(f, "DELETE")
             }
         }
@@ -8700,6 +8713,8 @@ impl Display for MergeAction {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct MergeClause {
+    /// The `WHEN` token that starts the sub-expression.
+    pub when_token: AttachedToken,
     pub clause_kind: MergeClauseKind,
     pub predicate: Option<Expr>,
     pub action: MergeAction,
@@ -8708,6 +8723,7 @@ pub struct MergeClause {
 impl Display for MergeClause {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let MergeClause {
+            when_token: _,
             clause_kind,
             predicate,
             action,
@@ -8731,10 +8747,12 @@ impl Display for MergeClause {
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum OutputClause {
     Output {
+        output_token: AttachedToken,
         select_items: Vec<SelectItem>,
         into_table: Option<SelectInto>,
     },
     Returning {
+        returning_token: AttachedToken,
         select_items: Vec<SelectItem>,
     },
 }
@@ -8743,6 +8761,7 @@ impl fmt::Display for OutputClause {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             OutputClause::Output {
+                output_token: _,
                 select_items,
                 into_table,
             } => {
@@ -8754,7 +8773,10 @@ impl fmt::Display for OutputClause {
                 }
                 Ok(())
             }
-            OutputClause::Returning { select_items } => {
+            OutputClause::Returning {
+                returning_token: _,
+                select_items,
+            } => {
                 f.write_str("RETURNING ")?;
                 display_comma_separated(select_items).fmt(f)
             }
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
index cfaaf8f0..d54290b6 100644
--- a/src/ast/spans.rs
+++ b/src/ast/spans.rs
@@ -35,14 +35,15 @@ use super::{
     FunctionArgumentClause, FunctionArgumentList, FunctionArguments, GroupByExpr, HavingBound,
     IfStatement, IlikeSelectItem, IndexColumn, Insert, Interpolate, InterpolateExpr, Join,
     JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, LimitClause,
-    MatchRecognizePattern, Measure, NamedParenthesizedList, NamedWindowDefinition, ObjectName,
-    ObjectNamePart, Offset, OnConflict, OnConflictAction, OnInsert, OpenStatement, OrderBy,
-    OrderByExpr, OrderByKind, Partition, PivotValueSource, ProjectionSelect, Query, RaiseStatement,
-    RaiseStatementValue, ReferentialAction, RenameSelectItem, ReplaceSelectElement,
-    ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript,
-    SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint, TableFactor, TableObject,
-    TableOptionsClustered, TableWithJoins, Update, UpdateTableFromKind, Use, Value, Values,
-    ViewColumnDef, WhileStatement, WildcardAdditionalOptions, With, WithFill,
+    MatchRecognizePattern, Measure, MergeAction, MergeClause, MergeInsertExpr, MergeInsertKind,
+    NamedParenthesizedList, NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict,
+    OnConflictAction, OnInsert, OpenStatement, OrderBy, OrderByExpr, OrderByKind, OutputClause,
+    Partition, PivotValueSource, ProjectionSelect, Query, RaiseStatement, RaiseStatementValue,
+    ReferentialAction, RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select,
+    SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript, SymbolDefinition, TableAlias,
+    TableAliasColumnDef, TableConstraint, TableFactor, TableObject, TableOptionsClustered,
+    TableWithJoins, Update, UpdateTableFromKind, Use, Value, Values, ViewColumnDef, WhileStatement,
+    WildcardAdditionalOptions, With, WithFill,
 };
 
 /// Given an iterator of spans, return the [Span::union] of all spans.
@@ -287,7 +288,6 @@ impl Spanned for Values {
 /// - [Statement::Explain]
 /// - [Statement::Savepoint]
 /// - [Statement::ReleaseSavepoint]
-/// - [Statement::Merge]
 /// - [Statement::Cache]
 /// - [Statement::UNCache]
 /// - [Statement::CreateSequence]
@@ -439,7 +439,20 @@ impl Spanned for Statement {
             Statement::Explain { .. } => Span::empty(),
             Statement::Savepoint { .. } => Span::empty(),
             Statement::ReleaseSavepoint { .. } => Span::empty(),
-            Statement::Merge { .. } => Span::empty(),
+            Statement::Merge {
+                merge_token,
+                into: _,
+                table: _,
+                source: _,
+                on,
+                clauses,
+                output,
+            } => union_spans(
+                [merge_token.0.span, on.span()]
+                    .into_iter()
+                    .chain(clauses.iter().map(Spanned::span))
+                    .chain(output.iter().map(Spanned::span)),
+            ),
             Statement::Cache { .. } => Span::empty(),
             Statement::UNCache { .. } => Span::empty(),
             Statement::CreateSequence { .. } => Span::empty(),
@@ -2381,11 +2394,72 @@ impl Spanned for CreateOperatorClass {
     }
 }
 
+impl Spanned for MergeClause {
+    fn span(&self) -> Span {
+        union_spans([self.when_token.0.span, self.action.span()].into_iter())
+    }
+}
+
+impl Spanned for MergeAction {
+    fn span(&self) -> Span {
+        match self {
+            MergeAction::Insert(expr) => expr.span(),
+            MergeAction::Update {
+                update_token,
+                assignments,
+            } => union_spans(
+                core::iter::once(update_token.0.span).chain(assignments.iter().map(Spanned::span)),
+            ),
+            MergeAction::Delete { delete_token } => delete_token.0.span,
+        }
+    }
+}
+
+impl Spanned for MergeInsertExpr {
+    fn span(&self) -> Span {
+        union_spans(
+            [
+                self.insert_token.0.span,
+                self.kind_token.0.span,
+                match self.kind {
+                    MergeInsertKind::Values(ref values) => values.span(),
+                    MergeInsertKind::Row => Span::empty(), // ~ covered by `kind_token`
+                },
+            ]
+            .into_iter()
+            .chain(self.columns.iter().map(|i| i.span)),
+        )
+    }
+}
+
+impl Spanned for OutputClause {
+    fn span(&self) -> Span {
+        match self {
+            OutputClause::Output {
+                output_token,
+                select_items,
+                into_table,
+            } => union_spans(
+                core::iter::once(output_token.0.span)
+                    .chain(into_table.iter().map(Spanned::span))
+                    .chain(select_items.iter().map(Spanned::span)),
+            ),
+            OutputClause::Returning {
+                returning_token,
+                select_items,
+            } => union_spans(
+                core::iter::once(returning_token.0.span)
+                    .chain(select_items.iter().map(Spanned::span)),
+            ),
+        }
+    }
+}
+
 #[cfg(test)]
 pub mod tests {
     use crate::dialect::{Dialect, GenericDialect, SnowflakeDialect};
     use crate::parser::Parser;
-    use crate::tokenizer::Span;
+    use crate::tokenizer::{Location, Span};
 
     use super::*;
 
@@ -2647,4 +2721,203 @@ WHERE id = 1
         assert_eq!(stmt_span.start, (2, 7).into());
         assert_eq!(stmt_span.end, (4, 24).into());
     }
+
+    #[test]
+    fn test_merge_statement_spans() {
+        let sql = r#"
+        -- plain merge statement; no RETURNING, no OUTPUT
+
+        MERGE INTO target_table USING source_table
+                ON target_table.id = source_table.oooid
+
+        /* an inline comment */ WHEN NOT MATCHED THEN
+            INSERT (ID, description)
+               VALUES (source_table.id, source_table.description)
+
+            -- another one
+                WHEN MATCHED AND target_table.x = 'X' THEN
+            UPDATE SET target_table.description = source_table.description
+
+              WHEN MATCHED AND target_table.x != 'X' THEN   DELETE
+        WHEN NOT MATCHED AND 1 THEN INSERT (product, quantity) ROW 
+        "#;
+
+        let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap();
+        assert_eq!(1, r.len());
+
+        // ~ assert the span of the whole statement
+        let stmt_span = r[0].span();
+        assert_eq!(stmt_span.start, (4, 9).into());
+        assert_eq!(stmt_span.end, (16, 67).into());
+
+        // ~ individual tokens within the statement
+        let Statement::Merge {
+            merge_token,
+            into: _,
+            table: _,
+            source: _,
+            on: _,
+            clauses,
+            output,
+        } = &r[0]
+        else {
+            panic!("not a MERGE statement");
+        };
+        assert_eq!(
+            merge_token.0.span,
+            Span::new(Location::new(4, 9), Location::new(4, 14))
+        );
+        assert_eq!(clauses.len(), 4);
+
+        // ~ the INSERT clause's TOKENs
+        assert_eq!(
+            clauses[0].when_token.0.span,
+            Span::new(Location::new(7, 33), Location::new(7, 37))
+        );
+        if let MergeAction::Insert(MergeInsertExpr {
+            insert_token,
+            kind_token,
+            ..
+        }) = &clauses[0].action
+        {
+            assert_eq!(
+                insert_token.0.span,
+                Span::new(Location::new(8, 13), Location::new(8, 19))
+            );
+            assert_eq!(
+                kind_token.0.span,
+                Span::new(Location::new(9, 16), Location::new(9, 22))
+            );
+        } else {
+            panic!("not a MERGE INSERT clause");
+        }
+
+        // ~ the UPDATE token(s)
+        assert_eq!(
+            clauses[1].when_token.0.span,
+            Span::new(Location::new(12, 17), Location::new(12, 21))
+        );
+        if let MergeAction::Update {
+            update_token,
+            assignments: _,
+        } = &clauses[1].action
+        {
+            assert_eq!(
+                update_token.0.span,
+                Span::new(Location::new(13, 13), Location::new(13, 19))
+            );
+        } else {
+            panic!("not a MERGE UPDATE clause");
+        }
+
+        // the DELETE token(s)
+        assert_eq!(
+            clauses[2].when_token.0.span,
+            Span::new(Location::new(15, 15), Location::new(15, 19))
+        );
+        if let MergeAction::Delete { delete_token } = &clauses[2].action {
+            assert_eq!(
+                delete_token.0.span,
+                Span::new(Location::new(15, 61), Location::new(15, 67))
+            );
+        } else {
+            panic!("not a MERGE DELETE clause");
+        }
+
+        // ~ an INSERT clause's ROW token
+        assert_eq!(
+            clauses[3].when_token.0.span,
+            Span::new(Location::new(16, 9), Location::new(16, 13))
+        );
+        if let MergeAction::Insert(MergeInsertExpr {
+            insert_token,
+            kind_token,
+            ..
+        }) = &clauses[3].action
+        {
+            assert_eq!(
+                insert_token.0.span,
+                Span::new(Location::new(16, 37), Location::new(16, 43))
+            );
+            assert_eq!(
+                kind_token.0.span,
+                Span::new(Location::new(16, 64), Location::new(16, 67))
+            );
+        } else {
+            panic!("not a MERGE INSERT clause");
+        }
+
+        assert!(output.is_none());
+    }
+
+    #[test]
+    fn test_merge_statement_spans_with_returning() {
+        let sql = r#"
+    MERGE INTO wines AS w
+    USING wine_stock_changes AS s
+        ON s.winename = w.winename
+    WHEN NOT MATCHED AND s.stock_delta > 0 THEN INSERT VALUES (s.winename, s.stock_delta)
+    WHEN MATCHED AND w.stock + s.stock_delta > 0 THEN UPDATE SET stock = w.stock + s.stock_delta
+    WHEN MATCHED THEN DELETE
+    RETURNING merge_action(), w.*
+        "#;
+
+        let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap();
+        assert_eq!(1, r.len());
+
+        // ~ assert the span of the whole statement
+        let stmt_span = r[0].span();
+        assert_eq!(
+            stmt_span,
+            Span::new(Location::new(2, 5), Location::new(8, 34))
+        );
+
+        // ~ individual tokens within the statement
+        if let Statement::Merge { output, .. } = &r[0] {
+            if let Some(OutputClause::Returning {
+                returning_token, ..
+            }) = output
+            {
+                assert_eq!(
+                    returning_token.0.span,
+                    Span::new(Location::new(8, 5), Location::new(8, 14))
+                );
+            } else {
+                panic!("unexpected MERGE output clause");
+            }
+        } else {
+            panic!("not a MERGE statement");
+        };
+    }
+
+    #[test]
+    fn test_merge_statement_spans_with_output() {
+        let sql = r#"MERGE INTO a USING b ON a.id = b.id
+        WHEN MATCHED THEN DELETE
+              OUTPUT inserted.*"#;
+
+        let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap();
+        assert_eq!(1, r.len());
+
+        // ~ assert the span of the whole statement
+        let stmt_span = r[0].span();
+        assert_eq!(
+            stmt_span,
+            Span::new(Location::new(1, 1), Location::new(3, 32))
+        );
+
+        // ~ individual tokens within the statement
+        if let Statement::Merge { output, .. } = &r[0] {
+            if let Some(OutputClause::Output { output_token, .. }) = output {
+                assert_eq!(
+                    output_token.0.span,
+                    Span::new(Location::new(3, 15), Location::new(3, 21))
+                );
+            } else {
+                panic!("unexpected MERGE output clause");
+            }
+        } else {
+            panic!("not a MERGE statement");
+        };
+    }
 }
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index f835f541..1fa7f796 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -622,7 +622,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(),
+                Keyword::MERGE => self.parse_merge(next_token),
                 // `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(),
@@ -12125,8 +12125,11 @@ impl<'a> Parser<'a> {
     /// Parse a MERGE statement, returning a `Box`ed SetExpr
     ///
     /// This is used to reduce the size of the stack frames in debug builds
-    fn parse_merge_setexpr_boxed(&mut self) -> Result<Box<SetExpr>, ParserError> {
-        Ok(Box::new(SetExpr::Merge(self.parse_merge()?)))
+    fn parse_merge_setexpr_boxed(
+        &mut self,
+        merge_token: TokenWithSpan,
+    ) -> Result<Box<SetExpr>, ParserError> {
+        Ok(Box::new(SetExpr::Merge(self.parse_merge(merge_token)?)))
     }
 
     pub fn parse_delete(&mut self, delete_token: TokenWithSpan) -> Result<Statement, ParserError> {
@@ -12344,7 +12347,7 @@ impl<'a> Parser<'a> {
         } else if self.parse_keyword(Keyword::MERGE) {
             Ok(Query {
                 with,
-                body: self.parse_merge_setexpr_boxed()?,
+                body: self.parse_merge_setexpr_boxed(self.get_current_token().clone())?,
                 limit_clause: None,
                 order_by: None,
                 fetch: None,
@@ -17200,6 +17203,7 @@ impl<'a> Parser<'a> {
             if !(self.parse_keyword(Keyword::WHEN)) {
                 break;
             }
+            let when_token = self.get_current_token().clone();
 
             let mut clause_kind = MergeClauseKind::Matched;
             if self.parse_keyword(Keyword::NOT) {
@@ -17235,12 +17239,16 @@ impl<'a> Parser<'a> {
                         clause_kind,
                         MergeClauseKind::NotMatched | MergeClauseKind::NotMatchedByTarget
                     ) {
-                        return Err(ParserError::ParserError(format!(
-                            "UPDATE is not allowed in a {clause_kind} merge clause"
-                        )));
+                        return parser_err!(
+                            format_args!("UPDATE is not allowed in a {clause_kind} merge clause"),
+                            self.get_current_token().span.start
+                        );
                     }
+
+                    let update_token = self.get_current_token().clone();
                     self.expect_keyword_is(Keyword::SET)?;
                     MergeAction::Update {
+                        update_token: update_token.into(),
                         assignments: self.parse_comma_separated(Parser::parse_assignment)?,
                     }
                 }
@@ -17249,42 +17257,58 @@ impl<'a> Parser<'a> {
                         clause_kind,
                         MergeClauseKind::NotMatched | MergeClauseKind::NotMatchedByTarget
                     ) {
-                        return Err(ParserError::ParserError(format!(
-                            "DELETE is not allowed in a {clause_kind} merge clause"
-                        )));
+                        return parser_err!(
+                            format_args!("DELETE is not allowed in a {clause_kind} merge clause"),
+                            self.get_current_token().span.start
+                        );
+                    };
+
+                    let delete_token = self.get_current_token().clone();
+                    MergeAction::Delete {
+                        delete_token: delete_token.into(),
                     }
-                    MergeAction::Delete
                 }
                 Some(Keyword::INSERT) => {
                     if !matches!(
                         clause_kind,
                         MergeClauseKind::NotMatched | MergeClauseKind::NotMatchedByTarget
                     ) {
-                        return Err(ParserError::ParserError(format!(
-                            "INSERT is not allowed in a {clause_kind} merge clause"
-                        )));
-                    }
+                        return parser_err!(
+                            format_args!("INSERT is not allowed in a {clause_kind} merge clause"),
+                            self.get_current_token().span.start
+                        );
+                    };
+
+                    let insert_token = self.get_current_token().clone();
                     let is_mysql = dialect_of!(self is MySqlDialect);
 
                     let columns = self.parse_parenthesized_column_list(Optional, is_mysql)?;
-                    let kind = if dialect_of!(self is BigQueryDialect | GenericDialect)
+                    let (kind, kind_token) = if dialect_of!(self is BigQueryDialect | GenericDialect)
                         && self.parse_keyword(Keyword::ROW)
                     {
-                        MergeInsertKind::Row
+                        (MergeInsertKind::Row, self.get_current_token().clone())
                     } else {
                         self.expect_keyword_is(Keyword::VALUES)?;
+                        let values_token = self.get_current_token().clone();
                         let values = self.parse_values(is_mysql, false)?;
-                        MergeInsertKind::Values(values)
+                        (MergeInsertKind::Values(values), values_token)
                     };
-                    MergeAction::Insert(MergeInsertExpr { columns, kind })
+                    MergeAction::Insert(MergeInsertExpr {
+                        insert_token: insert_token.into(),
+                        columns,
+                        kind_token: kind_token.into(),
+                        kind,
+                    })
                 }
                 _ => {
-                    return Err(ParserError::ParserError(
-                        "expected UPDATE, DELETE or INSERT in merge clause".to_string(),
-                    ));
+                    return parser_err!(
+                        "expected UPDATE, DELETE or INSERT in merge clause",
+                        self.peek_token_ref().span.start
+                    );
                 }
             };
             clauses.push(MergeClause {
+                when_token: when_token.into(),
                 clause_kind,
                 predicate,
                 action: merge_clause,
@@ -17293,7 +17317,11 @@ impl<'a> Parser<'a> {
         Ok(clauses)
     }
 
-    fn parse_output(&mut self, start_keyword: Keyword) -> Result<OutputClause, ParserError> {
+    fn parse_output(
+        &mut self,
+        start_keyword: Keyword,
+        start_token: TokenWithSpan,
+    ) -> Result<OutputClause, ParserError> {
         let select_items = self.parse_projection()?;
         let into_table = if start_keyword == Keyword::OUTPUT && self.peek_keyword(Keyword::INTO) {
             self.expect_keyword_is(Keyword::INTO)?;
@@ -17304,11 +17332,15 @@ impl<'a> Parser<'a> {
 
         Ok(if start_keyword == Keyword::OUTPUT {
             OutputClause::Output {
+                output_token: start_token.into(),
                 select_items,
                 into_table,
             }
         } else {
-            OutputClause::Returning { select_items }
+            OutputClause::Returning {
+                returning_token: start_token.into(),
+                select_items,
+            }
         })
     }
 
@@ -17328,7 +17360,7 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub fn parse_merge(&mut self) -> Result<Statement, ParserError> {
+    pub fn parse_merge(&mut self, merge_token: TokenWithSpan) -> Result<Statement, ParserError> {
         let into = self.parse_keyword(Keyword::INTO);
 
         let table = self.parse_table_factor()?;
@@ -17339,11 +17371,12 @@ impl<'a> Parser<'a> {
         let on = self.parse_expr()?;
         let clauses = self.parse_merge_clauses()?;
         let output = match self.parse_one_of_keywords(&[Keyword::OUTPUT, Keyword::RETURNING]) {
-            Some(start_keyword) => Some(self.parse_output(start_keyword)?),
+            Some(keyword) => Some(self.parse_output(keyword, self.get_current_token().clone())?),
             None => None,
         };
 
         Ok(Statement::Merge {
+            merge_token: merge_token.into(),
             into,
             table,
             source,
diff --git a/tests/sqlparser_bigquery.rs b/tests/sqlparser_bigquery.rs
index 0ef1c4f0..15bf59cd 100644
--- a/tests/sqlparser_bigquery.rs
+++ b/tests/sqlparser_bigquery.rs
@@ -1805,7 +1805,9 @@ fn parse_merge() {
         "WHEN NOT MATCHED THEN INSERT VALUES (1, DEFAULT)",
     );
     let insert_action = MergeAction::Insert(MergeInsertExpr {
+        insert_token: AttachedToken::empty(),
         columns: vec![Ident::new("product"), Ident::new("quantity")],
+        kind_token: AttachedToken::empty(),
         kind: MergeInsertKind::Values(Values {
             value_keyword: false,
             explicit_row: false,
@@ -1813,6 +1815,7 @@ fn parse_merge() {
         }),
     });
     let update_action = MergeAction::Update {
+        update_token: AttachedToken::empty(),
         assignments: vec![
             Assignment {
                 target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new("a")])),
@@ -1875,82 +1878,111 @@ fn parse_merge() {
             assert_eq!(
                 vec![
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: Some(Expr::value(number("1"))),
                         action: insert_action.clone(),
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatchedByTarget,
                         predicate: Some(Expr::value(number("1"))),
                         action: insert_action.clone(),
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatchedByTarget,
                         predicate: None,
                         action: insert_action,
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatchedBySource,
                         predicate: Some(Expr::value(number("2"))),
-                        action: MergeAction::Delete
+                        action: MergeAction::Delete {
+                            delete_token: AttachedToken::empty(),
+                        }
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatchedBySource,
                         predicate: None,
-                        action: MergeAction::Delete
+                        action: MergeAction::Delete {
+                            delete_token: AttachedToken::empty()
+                        }
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatchedBySource,
                         predicate: Some(Expr::value(number("1"))),
                         action: update_action.clone(),
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: Some(Expr::value(number("1"))),
                         action: MergeAction::Insert(MergeInsertExpr {
+                            insert_token: AttachedToken::empty(),
                             columns: vec![Ident::new("product"), Ident::new("quantity"),],
+                            kind_token: AttachedToken::empty(),
                             kind: MergeInsertKind::Row,
                         })
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: None,
                         action: MergeAction::Insert(MergeInsertExpr {
+                            insert_token: AttachedToken::empty(),
                             columns: vec![Ident::new("product"), Ident::new("quantity"),],
+                            kind_token: AttachedToken::empty(),
                             kind: MergeInsertKind::Row,
                         })
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: Some(Expr::value(number("1"))),
                         action: MergeAction::Insert(MergeInsertExpr {
+                            insert_token: AttachedToken::empty(),
                             columns: vec![],
+                            kind_token: AttachedToken::empty(),
                             kind: MergeInsertKind::Row
                         })
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: None,
                         action: MergeAction::Insert(MergeInsertExpr {
+                            insert_token: AttachedToken::empty(),
                             columns: vec![],
+                            kind_token: AttachedToken::empty(),
                             kind: MergeInsertKind::Row
                         })
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::Matched,
                         predicate: Some(Expr::value(number("1"))),
-                        action: MergeAction::Delete,
+                        action: MergeAction::Delete {
+                            delete_token: AttachedToken::empty(),
+                        },
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::Matched,
                         predicate: None,
                         action: update_action,
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: None,
                         action: MergeAction::Insert(MergeInsertExpr {
+                            insert_token: AttachedToken::empty(),
                             columns: vec![Ident::new("a"), Ident::new("b"),],
+                            kind_token: AttachedToken::empty(),
                             kind: MergeInsertKind::Values(Values {
                                 value_keyword: false,
                                 explicit_row: false,
@@ -1962,10 +1994,13 @@ fn parse_merge() {
                         })
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: None,
                         action: MergeAction::Insert(MergeInsertExpr {
+                            insert_token: AttachedToken::empty(),
                             columns: vec![],
+                            kind_token: AttachedToken::empty(),
                             kind: MergeInsertKind::Values(Values {
                                 value_keyword: false,
                                 explicit_row: false,
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index b06f1141..ba1e6448 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -9921,10 +9921,13 @@ fn parse_merge() {
                 clauses,
                 vec![
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::NotMatched,
                         predicate: None,
                         action: MergeAction::Insert(MergeInsertExpr {
+                            insert_token: AttachedToken::empty(),
                             columns: vec![Ident::new("A"), Ident::new("B"), Ident::new("C")],
+                            kind_token: AttachedToken::empty(),
                             kind: MergeInsertKind::Values(Values {
                                 value_keyword: false,
                                 explicit_row: false,
@@ -9946,6 +9949,7 @@ fn parse_merge() {
                         }),
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::Matched,
                         predicate: Some(Expr::BinaryOp {
                             left: Box::new(Expr::CompoundIdentifier(vec![
@@ -9958,6 +9962,7 @@ fn parse_merge() {
                             )),
                         }),
                         action: MergeAction::Update {
+                            update_token: AttachedToken::empty(),
                             assignments: vec![
                                 Assignment {
                                     target: AssignmentTarget::ColumnName(ObjectName::from(vec![
@@ -9983,9 +9988,12 @@ fn parse_merge() {
                         },
                     },
                     MergeClause {
+                        when_token: AttachedToken::empty(),
                         clause_kind: MergeClauseKind::Matched,
                         predicate: None,
-                        action: MergeAction::Delete,
+                        action: MergeAction::Delete {
+                            delete_token: AttachedToken::empty(),
+                        },
                     },
                 ]
             );


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org