feat: 支持 MERGE INTO 语法，冲突时自动更新非键列

Co-authored-by: nnhy <506367+nnhy@users.noreply.github.com>

Author: Copilot

NewLife.NovaDb/Sql/SqlAst.cs

@@ -31,6 +31,8 @@ public enum SqlStatementType
     TruncateTable,
     /// <summary>UPSERT（INSERT ... ON DUPLICATE KEY UPDATE）</summary>
     Upsert,
+    /// <summary>MERGE INTO（冲突时自动更新）</summary>
+    Merge,
     /// <summary>EXPLAIN 查询计划</summary>
     Explain
 }
@@ -227,6 +229,22 @@ public class InsertStatement : SqlStatement
     public List<List<SqlExpression>> ValuesList { get; set; } = [];
 }
 
+/// <summary>MERGE INTO 语句（冲突时自动更新非键列）</summary>
+public class MergeStatement : SqlStatement
+{
+    /// <summary>语句类型</summary>
+    public override SqlStatementType StatementType => SqlStatementType.Merge;
+
+    /// <summary>表名</summary>
+    public String TableName { get; set; } = String.Empty;
+
+    /// <summary>列名列表（可选）</summary>
+    public List<String>? Columns { get; set; }
+
+    /// <summary>值列表（多行插入）</summary>
+    public List<List<SqlExpression>> ValuesList { get; set; } = [];
+}
+
 /// <summary>UPSERT 语句（INSERT ... ON DUPLICATE KEY UPDATE）</summary>
 public class UpsertStatement : SqlStatement
 {

NewLife.NovaDb/Sql/SqlEngine.DML.cs

@@ -186,5 +186,118 @@ private SqlResult ExecuteUpsert(UpsertStatement stmt, Dictionary<String, Object?
         return new SqlResult { AffectedRows = affectedRows };
     }
 
+    private SqlResult ExecuteMerge(MergeStatement stmt, Dictionary<String, Object?>? parameters)
+    {
+        var table = GetTable(stmt.TableName);
+        var schema = GetSchema(stmt.TableName);
+        var pkCol = schema.GetPrimaryKeyColumn()
+            ?? throw new NovaException(ErrorCode.InvalidArgument, "MERGE requires a table with a primary key");
+
+        using var tx = _txManager.BeginTransaction();
+        var affectedRows = 0;
+
+        foreach (var values in stmt.ValuesList)
+        {
+            var row = new Object?[schema.Columns.Count];
+
+            if (stmt.Columns != null)
+            {
+                for (var i = 0; i < stmt.Columns.Count; i++)
+                {
+                    var colIdx = schema.GetColumnIndex(stmt.Columns[i]);
+                    row[colIdx] = EvaluateExpression(values[i], null, schema, parameters);
+                }
+            }
+            else
+            {
+                if (values.Count != schema.Columns.Count)
+                    throw new NovaException(ErrorCode.InvalidArgument,
+                        $"MERGE values count ({values.Count}) does not match column count ({schema.Columns.Count})");
+
+                for (var i = 0; i < values.Count; i++)
+                {
+                    row[i] = EvaluateExpression(values[i], null, schema, parameters);
+                }
+            }
+
+            ConvertRowTypes(row, schema);
+
+            // 检测唯一冲突：优先检查主键，再检查唯一索引
+            Object? existingPkValue = null;
+            Object?[]? existingRow = null;
+
+            // 1. 检查主键冲突
+            var pkValue = row[pkCol.Ordinal];
+            if (pkValue != null)
+            {
+                existingRow = table.Get(tx, pkValue);
+                if (existingRow != null)
+                    existingPkValue = pkValue;
+            }
+
+            // 2. 若无主键冲突，检查唯一索引冲突
+            if (existingRow == null)
+            {
+                foreach (var indexDef in schema.Indexes)
+                {
+                    if (!indexDef.IsUnique) continue;
+
+                    var indexKeyValues = new Object?[indexDef.Columns.Count];
+                    for (var i = 0; i < indexDef.Columns.Count; i++)
+                    {
+                        var colIdx = schema.GetColumnIndex(indexDef.Columns[i]);
+                        indexKeyValues[i] = row[colIdx];
+                    }
+
+                    var matchedPks = table.LookupByIndex(indexDef.IndexName, indexKeyValues);
+                    if (matchedPks != null && matchedPks.Count > 0)
+                    {
+                        existingPkValue = matchedPks[0];
+                        existingRow = table.Get(tx, existingPkValue);
+                        break;
+                    }
+                }
+            }
+
+            if (existingRow != null)
+            {
+                // 冲突：用 VALUES 数据更新非主键列
+                var newRow = new Object?[schema.Columns.Count];
+                Array.Copy(existingRow, newRow, existingRow.Length);
+
+                if (stmt.Columns != null)
+                {
+                    for (var i = 0; i < stmt.Columns.Count; i++)
+                    {
+                        var colIdx = schema.GetColumnIndex(stmt.Columns[i]);
+                        if (colIdx == pkCol.Ordinal) continue;
+                        newRow[colIdx] = row[colIdx];
+                    }
+                }
+                else
+                {
+                    for (var i = 0; i < schema.Columns.Count; i++)
+                    {
+                        if (i == pkCol.Ordinal) continue;
+                        newRow[i] = row[i];
+                    }
+                }
+
+                ConvertRowTypes(newRow, schema);
+                table.Update(tx, existingPkValue!, newRow);
+            }
+            else
+            {
+                // 无冲突：执行 INSERT
+                table.Insert(tx, row);
+            }
+
+            affectedRows++;
+        }
+
+        tx.Commit();
+        return new SqlResult { AffectedRows = affectedRows };
+    }
+
     #endregion
 }

NewLife.NovaDb/Sql/SqlEngine.cs

@@ -120,6 +120,7 @@ public SqlResult Execute(String sql, Dictionary<String, Object?>? parameters = n
             // DML 语句
             InsertStatement insert => TrackInsert(ExecuteInsert(insert, parameters), sql),
             UpsertStatement upsert => TrackInsert(ExecuteUpsert(upsert, parameters), sql),
+            MergeStatement merge => TrackInsert(ExecuteMerge(merge, parameters), sql),
             UpdateStatement update => TrackUpdate(ExecuteUpdate(update, parameters), sql),
             DeleteStatement delete => TrackDelete(ExecuteDelete(delete, parameters), sql),
 

NewLife.NovaDb/Sql/SqlLexer.cs

@@ -76,6 +76,7 @@ public class SqlLexer
         ["TRUNCATE"] = SqlTokenType.Truncate,
         ["DUPLICATE"] = SqlTokenType.Duplicate,
         ["EXPLAIN"] = SqlTokenType.Explain,
+        ["MERGE"] = SqlTokenType.Merge,
     };
 
     /// <summary>创建词法分析器</summary>

NewLife.NovaDb/Sql/SqlParser.cs

@@ -28,6 +28,7 @@ public SqlStatement Parse()
         {
             SqlTokenType.Select => (SqlStatement)ParseSelect(),
             SqlTokenType.Insert => ParseInsert(),
+            SqlTokenType.Merge => ParseMerge(),
             SqlTokenType.Update => ParseUpdate(),
             SqlTokenType.Delete => ParseDelete(),
             SqlTokenType.Create => ParseCreate(),
@@ -460,6 +461,57 @@ private SqlStatement ParseInsert()
         };
     }
 
+    private MergeStatement ParseMerge()
+    {
+        Expect(SqlTokenType.Merge);
+        Expect(SqlTokenType.Into);
+
+        var tableName = ExpectIdentifier();
+
+        // 可选的列名列表
+        List<String>? columns = null;
+        if (Peek().Type == SqlTokenType.LeftParen)
+        {
+            Advance();
+            columns = [];
+
+            do
+            {
+                columns.Add(ExpectIdentifier());
+            }
+            while (TryConsume(SqlTokenType.Comma));
+
+            Expect(SqlTokenType.RightParen);
+        }
+
+        Expect(SqlTokenType.Values);
+
+        // 解析一组或多组值
+        var valuesList = new List<List<SqlExpression>>();
+        do
+        {
+            Expect(SqlTokenType.LeftParen);
+            var values = new List<SqlExpression>();
+
+            do
+            {
+                values.Add(ParseExpression());
+            }
+            while (TryConsume(SqlTokenType.Comma));
+
+            Expect(SqlTokenType.RightParen);
+            valuesList.Add(values);
+        }
+        while (TryConsume(SqlTokenType.Comma));
+
+        return new MergeStatement
+        {
+            TableName = tableName,
+            Columns = columns,
+            ValuesList = valuesList
+        };
+    }
+
     private UpdateStatement ParseUpdate()
     {
         Expect(SqlTokenType.Update);

NewLife.NovaDb/Sql/SqlToken.cs

@@ -132,6 +132,8 @@ public enum SqlTokenType
     Duplicate,
     /// <summary>EXPLAIN</summary>
     Explain,
+    /// <summary>MERGE</summary>
+    Merge,
 
     // 标识符与字面量
     /// <summary>标识符</summary>

XUnitTest/Sql/SqlEngineFullTests.cs

@@ -716,4 +716,136 @@ public void UpsertTrackedAsInsert()
     }
 
     #endregion
+
+    #region MERGE INTO 测试
+
+    [Fact(DisplayName = "MERGE INTO 行不存在时执行插入")]
+    public void MergeInsertWhenNotExists()
+    {
+        CreateUsersTable();
+
+        var result = _engine.Execute("MERGE INTO users (id, name, age) VALUES (1, 'Alice', 25)");
+        Assert.Equal(1, result.AffectedRows);
+
+        var select = _engine.Execute("SELECT * FROM users WHERE id = 1");
+        Assert.Single(select.Rows!);
+        Assert.Equal("Alice", select.Rows![0][1]);
+        Assert.Equal(25, select.Rows![0][2]);
+    }
+
+    [Fact(DisplayName = "MERGE INTO 主键冲突时执行更新")]
+    public void MergeUpdateWhenPkConflict()
+    {
+        SeedUsers();
+
+        var result = _engine.Execute("MERGE INTO users VALUES (1, 'AliceUpdated', 99)");
+        Assert.Equal(1, result.AffectedRows);
+
+        var select = _engine.Execute("SELECT * FROM users WHERE id = 1");
+        Assert.Single(select.Rows!);
+        Assert.Equal("AliceUpdated", select.Rows![0][1]);
+        Assert.Equal(99, select.Rows![0][2]);
+    }
+
+    [Fact(DisplayName = "MERGE INTO 不指定列名")]
+    public void MergeWithoutColumns()
+    {
+        SeedUsers();
+
+        _engine.Execute("MERGE INTO users VALUES (1, 'Updated', 88)");
+
+        var select = _engine.Execute("SELECT * FROM users WHERE id = 1");
+        Assert.Single(select.Rows!);
+        Assert.Equal("Updated", select.Rows![0][1]);
+        Assert.Equal(88, select.Rows![0][2]);
+    }
+
+    [Fact(DisplayName = "MERGE INTO 指定部分列名")]
+    public void MergeWithPartialColumns()
+    {
+        SeedUsers();
+
+        _engine.Execute("MERGE INTO users (id, name) VALUES (1, 'NewName')");
+
+        var select = _engine.Execute("SELECT * FROM users WHERE id = 1");
+        Assert.Single(select.Rows!);
+        Assert.Equal("NewName", select.Rows![0][1]);
+        // age 保持原值
+        Assert.Equal(25, select.Rows![0][2]);
+    }
+
+    [Fact(DisplayName = "MERGE INTO 多行混合插入和更新")]
+    public void MergeMultipleRowsMixed()
+    {
+        SeedUsers();
+
+        // id=1 已存在 → 更新；id=10 不存在 → 插入
+        var result = _engine.Execute("MERGE INTO users VALUES (1, 'AliceNew', 50), (10, 'Dave', 40)");
+        Assert.Equal(2, result.AffectedRows);
+
+        var select1 = _engine.Execute("SELECT * FROM users WHERE id = 1");
+        Assert.Equal("AliceNew", select1.Rows![0][1]);
+        Assert.Equal(50, select1.Rows![0][2]);
+
+        var select2 = _engine.Execute("SELECT * FROM users WHERE id = 10");
+        Assert.Single(select2.Rows!);
+        Assert.Equal("Dave", select2.Rows![0][1]);
+    }
+
+    [Fact(DisplayName = "MERGE INTO 唯一索引冲突时执行更新")]
+    public void MergeUpdateOnUniqueIndexConflict()
+    {
+        CreateUsersTable();
+        _engine.Execute("CREATE UNIQUE INDEX idx_name ON users (name)");
+        _engine.Execute("INSERT INTO users VALUES (1, 'Alice', 25)");
+
+        // 唯一索引冲突：name='Alice' 已存在
+        var result = _engine.Execute("MERGE INTO users VALUES (99, 'Alice', 99)");
+        Assert.Equal(1, result.AffectedRows);
+
+        // 应该更新已有行的 age，而非插入新行
+        var select = _engine.Execute("SELECT * FROM users WHERE id = 1");
+        Assert.Single(select.Rows!);
+        Assert.Equal("Alice", select.Rows![0][1]);
+        Assert.Equal(99, select.Rows![0][2]);
+
+        // 不应有 id=99 的行
+        var select2 = _engine.Execute("SELECT * FROM users WHERE id = 99");
+        Assert.Empty(select2.Rows!);
+    }
+
+    [Fact(DisplayName = "MERGE INTO 使用参数化值")]
+    public void MergeWithParameters()
+    {
+        SeedUsers();
+
+        var parameters = new Dictionary<String, Object?>
+        {
+            ["@id"] = 1,
+            ["@name"] = "ParamAlice",
+            ["@age"] = 77
+        };
+
+        var result = _engine.Execute(
+            "MERGE INTO users (id, name, age) VALUES (@id, @name, @age)",
+            parameters);
+        Assert.Equal(1, result.AffectedRows);
+
+        var select = _engine.Execute("SELECT * FROM users WHERE id = 1");
+        Assert.Equal("ParamAlice", select.Rows![0][1]);
+        Assert.Equal(77, select.Rows![0][2]);
+    }
+
+    [Fact(DisplayName = "MERGE INTO 计入 InsertCount")]
+    public void MergeTrackedAsInsert()
+    {
+        CreateUsersTable();
+        var beforeInsert = _engine.Metrics.InsertCount;
+
+        _engine.Execute("MERGE INTO users VALUES (1, 'Alice', 25)");
+
+        Assert.Equal(beforeInsert + 1, _engine.Metrics.InsertCount);
+    }
+
+    #endregion
 }