Exemplo de uma instrução de mesclagem simples no SQL Server

O exemplo a seguir usa T-SQL para mesclar duas tabelas no SQL Server. Ele usa os VALUES construtor de valor de tabela como a tabela de origem.

Suponha que criamos uma tabela assim:

CREATE TABLE Idiots (
    IdiotId int IDENTITY(1,1) NOT NULL,
    FirstName varchar(50),
    LastName varchar(50)
    );

INSERT INTO Idiots VALUES 
    ('Peter', 'Griffin'), 
    ('Homer', 'Simpson'), 
    ('Ned', 'Flanders');

SELECT * FROM Idiots;

Resultado:

+-----------+-------------+------------+
| IdiotId   | FirstName   | LastName   |
|-----------+-------------+------------|
| 1         | Peter       | Griffin    |
| 2         | Homer       | Simpson    |
| 3         | Ned         | Flanders   |
+-----------+-------------+------------+

E suponha que queremos realizar uma operação de mesclagem. Queremos inserir novas linhas, mas se já existir uma linha com valores que correspondam aos da nossa fonte, queremos atualizar a linha existente (em vez de inserir uma nova linha).

Podemos fazer assim:

DECLARE @Changes TABLE(Change VARCHAR(20));

MERGE INTO Idiots AS Target  
USING ( VALUES 
            (3, 'Ned', 'Okily Dokily!'), 
            (4, 'Lloyd','Christmas'), 
            (5, 'Harry', 'Dunne')
        ) AS Source ( IdiotId, FirstName, LastName )  
ON Target.IdiotId = Source.IdiotId
AND Target.FirstName = Source.FirstName
WHEN MATCHED THEN
    UPDATE SET FirstName = Source.FirstName, LastName = Source.LastName
WHEN NOT MATCHED BY TARGET THEN
    INSERT (FirstName, LastName) VALUES (Source.FirstName, Source.LastName)
OUTPUT $action INTO @Changes;

SELECT Change, COUNT(*) AS Count  
FROM @Changes  
GROUP BY Change;

Resultado:

+----------+---------+
| Change   | Count   |
|----------+---------|
| INSERT   | 2       |
| UPDATE   | 1       |
+----------+---------+

Duas novas linhas foram inseridas e uma foi atualizada.

Aqui, usamos um construtor de valor de tabela (VALUES ) para especificar os novos valores para a tabela.

Neste caso, verificamos o IdiotId e FirstName colunas. Basicamente, se o ID e o nome forem iguais, queremos atualizar a linha existente em vez de inserir uma nova.

Usamos WHEN MATCHED para especificar o que deve acontecer quando os dados de nossos VALUES cláusula corresponde aos dados na tabela de destino. Nesse caso, simplesmente atualizamos a linha com os novos dados de VALUES .

Usamos WHEN NOT MATCHED BY TARGET para especificar o que deve acontecer quando não houver correspondência. Neste caso, inserimos uma nova linha com os novos dados.

Também usamos uma variável chamada @Changes para visualizar a saída de nossa operação de mesclagem. Usamos o OUTPUT cláusula após a operação de mesclagem para isso. Foi isso que nos deu a tabela resultante acima.

Agora podemos verificar a tabela de destino para ver o impacto que a operação de mesclagem teve nela:

SELECT * FROM Idiots;

Resultado:

+-----------+-------------+---------------+
| IdiotId   | FirstName   | LastName      |
|-----------+-------------+---------------|
| 1         | Peter       | Griffin       |
| 2         | Homer       | Simpson       |
| 3         | Ned         | Okily Dokily! |
| 4         | Lloyd       | Christmas     |
| 5         | Harry       | Dunne         |
+-----------+-------------+---------------+

Podemos ver que o Idiota número 3 (Ned) teve seu sobrenome atualizado. Também podemos ver que dois novos idiotas foram adicionados à mesa (Lloyd e Harry).