Exempel på en enkel sammanfogningssats i SQL Server

Följande exempel använder T-SQL för att slå samman två tabeller i SQL Server. Den använder VALUES tabellvärdekonstruktor som källtabell.

Anta att vi skapar en tabell så här:

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;

Resultat:

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

Och anta att vi vill utföra en sammanslagning. Vi vill infoga nya rader, men om det redan finns en rad med värden som matchar de i vår källa, så vill vi uppdatera den befintliga raden istället (istället för att infoga en ny rad).

Vi kan göra det så här:

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;

Resultat:

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

Två nya rader infogades och en uppdaterades.

Här använde vi en tabellvärdekonstruktor (VALUES ) för att ange de nya värdena för tabellen.

I det här fallet kontrollerade vi IdiotId och FirstName kolumner. I grund och botten, om ID och förnamn är samma, då vill vi uppdatera den befintliga raden istället för att infoga en ny.

Vi använde WHEN MATCHED för att ange vad som ska hända när data från våra VALUES klausul matchar data i måltabellen. I det här fallet uppdaterar vi helt enkelt raden med nya data från VALUES .

Vi använde WHEN NOT MATCHED BY TARGET för att specificera vad som ska hända när det inte finns någon match. I det här fallet infogar vi en ny rad med nya data.

Vi använde också en variabel som heter @Changes för att se resultatet av vår sammanslagningsoperation. Vi använde OUTPUT klausul efter sammanslagningsoperationen för detta. Det var det som gav oss den resulterande tabellen ovan.

Vi kan nu kontrollera måltabellen för att se vilken inverkan sammanslagningsoperationen hade på den:

SELECT * FROM Idiots;

Resultat:

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

Vi kan se att Idiot nummer 3 (Ned) har fått sitt efternamn uppdaterat. Vi kan också se att två nya idioter har lagts till i tabellen (Lloyd och Harry).