No SQL Server,
VALUES é um construtor de valor de tabela que especifica um conjunto de expressões de valor de linha a serem construídas em uma tabela. Os
VALUES cláusula é frequentemente usada com INSERT instruções para inserir dados, mas também pode ser usado como uma tabela derivada no USING cláusula do MERGE instrução ou o FROM cláusula. Sintaxe
VALUES ( <row value expression list> ) [ ,...n ]
<row value expression list> ::=
{<row value expression> } [ ,...n ]
<row value expression> ::=
{ DEFAULT | NULL | expression }Observe que
DEFAULT é permitido apenas em um INSERT demonstração. DEFAULT força o SQL Server a inserir o valor padrão definido para a coluna. Se um padrão não existir para a coluna e a coluna permitir valores nulos, NULL está inserido. DEFAULT não pode ser usado em colunas de identidade. Exemplos
Aqui estão alguns exemplos que demonstram como
VALUES pode ser usado no SQL Server. Usado em um INSERT Declaração
Aqui está um exemplo de uso de
VALUES cláusula como parte de um INSERT demonstração: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');Isso criou uma tabela chamada
Idiots e inseriu três linhas nele. Agora podemos usar um
SELECT instrução para ver os novos valores na tabela:SELECT * FROM Idiots;Resultado:
+-----------+-------------+------------+ | IdiotId | FirstName | LastName | |-----------+-------------+------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Flanders | +-----------+-------------+------------+
Quando os
VALUES cláusula é usada em um INSERT instrução, há um limite de 1.000 linhas. Uma maneira de superar isso é usar VALUES em um SELECT instrução para criar uma tabela derivada. Isso evita que tenhamos que usar vários INSERT instruções ou fazendo uma inserção em massa. Usado em um SELECT Declaração
Podemos usar
VALUES para criar uma tabela derivada no FROM cláusula. Aqui está um SELECT declaração para demonstrar:SELECT
FirstName,
LastName
FROM
(VALUES
(1, 'Peter', 'Griffin'),
(2, 'Homer', 'Simpson'),
(3, 'Ned', 'Flanders')
) AS Idiots(IdiotId, FirstName, LastName)
WHERE IdiotId = 2;Resultado:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Simpson | +-------------+------------+
As tabelas derivadas podem ser usadas para superar o limite de 1.000 linhas ao inserir valores em um banco de dados.
Usado em um MERGE Declaração
Aqui está um exemplo de
VALUES sendo usado em um MERGE demonstração: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 | +----------+---------+
Nesse caso, uma linha foi atualizada e duas novas linhas foram inseridas, com base nos valores fornecidos no
VALUES cláusula. Aqui está a tabela resultante agora:
SELECT * FROM Idiots;Resultado:
+-----------+-------------+---------------+ | IdiotId | FirstName | LastName | |-----------+-------------+---------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Okily Dokily! | | 4 | Lloyd | Christmas | | 5 | Harry | Dunne | +-----------+-------------+---------------+
