Sqlserver
 sql >> Database >  >> RDS >> Sqlserver

Esempio di una semplice istruzione di unione in SQL Server

L'esempio seguente usa T-SQL per unire due tabelle in SQL Server. Utilizza i VALUES costruttore del valore della tabella come tabella di origine.

Supponiamo di creare una tabella come questa:

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;

Risultato:

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

E supponiamo di voler eseguire un'operazione di unione. Vogliamo inserire nuove righe, ma se esiste già una riga con valori che corrispondono a quelli nella nostra fonte, vogliamo invece aggiornare la riga esistente (invece di inserire una nuova riga).

Possiamo farlo in questo modo:

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;

Risultato:

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

Sono state inserite due nuove righe e una è stata aggiornata.

Qui, abbiamo usato un costruttore di valori di tabella (VALUES ) per specificare i nuovi valori per la tabella.

In questo caso abbiamo controllato IdiotId e FirstName colonne. Fondamentalmente, se l'ID e il nome sono gli stessi, vogliamo aggiornare la riga esistente invece di inserirne una nuova.

Abbiamo usato WHEN MATCHED per specificare cosa dovrebbe accadere quando i dati dai nostri VALUES la clausola corrisponde ai dati nella tabella di destinazione. In questo caso, aggiorniamo semplicemente la riga con i nuovi dati di VALUES .

Abbiamo usato WHEN NOT MATCHED BY TARGET per specificare cosa dovrebbe succedere quando non c'è corrispondenza. In questo caso inseriamo una nuova riga con i nuovi dati.

Abbiamo anche usato una variabile chiamata @Changes per visualizzare l'output della nostra operazione di unione. Abbiamo usato l'OUTPUT clausola dopo l'operazione di unione per questo. Questo è ciò che ci ha fornito la tabella risultante sopra.

Ora possiamo controllare la tabella di destinazione per vedere l'impatto che l'operazione di unione ha avuto su di essa:

SELECT * FROM Idiots;

Risultato:

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

Possiamo vedere che l'idiota numero 3 (Ned) ha avuto il suo cognome aggiornato. Possiamo anche vedere che due nuovi idioti sono stati aggiunti al tavolo (Lloyd e Harry).