En SQL Server, VALUES es un constructor de valores de tabla que especifica un conjunto de expresiones de valores de fila que se construirán en una tabla.
Los VALUES La cláusula se usa a menudo con INSERT sentencias para insertar datos, pero también se puede usar como una tabla derivada en el USING cláusula del MERGE declaración o el FROM cláusula.
Sintaxis
VALUES ( <row value expression list> ) [ ,...n ]
<row value expression list> ::=
{<row value expression> } [ ,...n ]
<row value expression> ::=
{ DEFAULT | NULL | expression }
Tenga en cuenta que DEFAULT solo se permite en un INSERT declaración. DEFAULT obliga a SQL Server a insertar el valor predeterminado definido para la columna. Si no existe un valor predeterminado para la columna y la columna permite valores nulos, NULL se inserta. DEFAULT no se puede usar en columnas de identidad.
Ejemplos
Estos son algunos ejemplos que demuestran cómo VALUES se puede utilizar en SQL Server.
Usado en un INSERT Declaración
Aquí hay un ejemplo del uso de VALUES cláusula como parte de un INSERT declaración:
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');
Eso creó una tabla llamada Idiots e insertó tres filas en él.
Ahora podemos usar un SELECT instrucción para ver los nuevos valores en la tabla:
SELECT * FROM Idiots;Resultado:
+-----------+-------------+------------+ | IdiotId | FirstName | LastName | |-----------+-------------+------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Flanders | +-----------+-------------+------------+
Cuando los VALUES cláusula se utiliza en un INSERT declaración, hay un límite de 1000 filas. Una forma de superar esto es usar VALUES en un SELECT instrucción para crear una tabla derivada. Eso nos evita tener que usar múltiples INSERT declaraciones o haciendo una inserción masiva.
Usado en un SELECT Declaración
Podemos usar VALUES para crear una tabla derivada en el FROM cláusula. Aquí hay un SELECT declaración para demostrar:
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 | +-------------+------------+
Las tablas derivadas se pueden usar para superar el límite de 1000 filas al insertar valores en una base de datos.
Usado en un MERGE Declaración
Aquí hay un ejemplo de VALUES siendo usado en un MERGE declaración:
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 | +----------+---------+
En este caso, se actualizó una fila y se insertaron dos filas nuevas, según los valores proporcionados en VALUES cláusula.
Aquí está la tabla resultante ahora:
SELECT * FROM Idiots;Resultado:
+-----------+-------------+---------------+ | IdiotId | FirstName | LastName | |-----------+-------------+---------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Okily Dokily! | | 4 | Lloyd | Christmas | | 5 | Harry | Dunne | +-----------+-------------+---------------+
