In SQL Server, VALUES è un costruttore di valori di tabella che specifica un insieme di espressioni di valori di riga da costruire in una tabella.
I VALUES La clausola è spesso usata con INSERT istruzioni per inserire dati, ma può anche essere usata come tabella derivata in USING clausola del MERGE istruzione o il FROM clausola.
Sintassi
VALUES ( <row value expression list> ) [ ,...n ]
<row value expression list> ::=
{<row value expression> } [ ,...n ]
<row value expression> ::=
{ DEFAULT | NULL | expression }
Nota che DEFAULT è consentito solo in un INSERT dichiarazione. DEFAULT forza SQL Server a inserire il valore predefinito definito per la colonna. Se non esiste un valore predefinito per la colonna e la colonna consente valori null, NULL è inserito. DEFAULT non può essere utilizzato nelle colonne identità.
Esempi
Ecco alcuni esempi che dimostrano come VALUES può essere utilizzato in SQL Server.
Utilizzato in un INSERT Dichiarazione
Ecco un esempio di utilizzo di VALUES clausola come parte di un INSERT dichiarazione:
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');
Ciò ha creato una tabella chiamata Idiots e inserito tre righe al suo interno.
Ora possiamo usare un SELECT istruzione per vedere i nuovi valori nella tabella:
SELECT * FROM Idiots;Risultato:
+-----------+-------------+------------+ | IdiotId | FirstName | LastName | |-----------+-------------+------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Flanders | +-----------+-------------+------------+
Quando il VALUES La clausola viene utilizzata in un INSERT istruzione, esiste un limite di 1000 righe. Un modo per superare questo problema è utilizzare VALUES in un SELECT istruzione per creare una tabella derivata. Questo ci evita di dover utilizzare più INSERT dichiarazioni o eseguendo un inserimento collettivo.
Utilizzato in un SELECT Dichiarazione
Possiamo usare VALUES per creare una tabella derivata nel FROM clausola. Ecco un SELECT dichiarazione da dimostrare:
SELECT
FirstName,
LastName
FROM
(VALUES
(1, 'Peter', 'Griffin'),
(2, 'Homer', 'Simpson'),
(3, 'Ned', 'Flanders')
) AS Idiots(IdiotId, FirstName, LastName)
WHERE IdiotId = 2;Risultato:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Simpson | +-------------+------------+
Le tabelle derivate possono essere utilizzate per superare il limite di 1000 righe durante l'inserimento di valori in un database.
Utilizzato in un MERGE Dichiarazione
Ecco un esempio di VALUES utilizzato in un MERGE dichiarazione:
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 | +----------+---------+
In questo caso è stata aggiornata una riga e sono state inserite due nuove righe, in base ai valori forniti nel VALUES clausola.
Ecco la tabella risultante ora:
SELECT * FROM Idiots;Risultato:
+-----------+-------------+---------------+ | IdiotId | FirstName | LastName | |-----------+-------------+---------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Okily Dokily! | | 4 | Lloyd | Christmas | | 5 | Harry | Dunne | +-----------+-------------+---------------+
