Exemple d'instruction de fusion simple dans SQL Server

L'exemple suivant utilise T-SQL pour fusionner deux tables dans SQL Server. Il utilise les VALUES constructeur de valeur de table comme table source.

Supposons que nous créons une table comme celle-ci :

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;

Résultat :

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

Et supposons que nous voulions effectuer une opération de fusion. Nous voulons insérer de nouvelles lignes, mais si une ligne existe déjà avec des valeurs qui correspondent à celles de notre source, nous voulons mettre à jour la ligne existante à la place (au lieu d'insérer une nouvelle ligne).

Nous pouvons le faire comme ceci :

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;

Résultat :

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

Deux nouvelles lignes ont été insérées et une a été mise à jour.

Ici, nous avons utilisé un constructeur de valeur de table (VALUES ) pour spécifier les nouvelles valeurs de la table.

Dans ce cas, nous avons vérifié le IdiotId et FirstName Colonnes. Fondamentalement, si l'ID et le prénom sont identiques, nous souhaitons mettre à jour la ligne existante au lieu d'en insérer une nouvelle.

Nous avons utilisé WHEN MATCHED pour spécifier ce qui doit se passer lorsque les données de nos VALUES clause correspond aux données de la table cible. Dans ce cas, nous mettons simplement à jour la ligne avec les nouvelles données de VALUES .

Nous avons utilisé WHEN NOT MATCHED BY TARGET pour spécifier ce qui doit se passer lorsqu'il n'y a pas de correspondance. Dans ce cas, nous insérons une nouvelle ligne avec les nouvelles données.

Nous avons également utilisé une variable appelée @Changes pour afficher le résultat de notre opération de fusion. Nous avons utilisé le OUTPUT clause après l'opération de fusion pour cela. C'est ce qui nous a donné le tableau résultant ci-dessus.

Nous pouvons maintenant vérifier la table cible pour voir l'impact que l'opération de fusion a eu sur elle :

SELECT * FROM Idiots;

Résultat :

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

Nous pouvons voir que l'Idiot numéro 3 (Ned) a vu son nom de famille mis à jour. Nous pouvons également voir que deux nouveaux idiots ont été ajoutés au tableau (Lloyd et Harry).