Dans MySQL, les VALUES renvoie un ensemble d'une ou plusieurs lignes sous forme de tableau. Fondamentalement, il s'agit d'un constructeur de valeurs de table conformément à la norme SQL, qui fonctionne également comme une instruction SQL autonome.
Les VALUES instruction a été introduite dans MySQL 8.0.19.
Syntaxe
La syntaxe officielle ressemble à ceci :
VALUES row_constructor_list [ORDER BY column_designator] [LIMIT number]
row_constructor_list:
ROW(value_list)[, ROW(value_list)][, ...]
value_list:
value[, value][, ...]
column_designator:
column_indexExemple
Voici un exemple simple pour illustrer son fonctionnement :
VALUES ROW(1, 2, 3), ROW(4, 5, 6);Résultat :
+----------+----------+----------+ | column_0 | column_1 | column_2 | +----------+----------+----------+ | 1 | 2 | 3 | | 4 | 5 | 6 | +----------+----------+----------+
Les colonnes résultantes sont implicitement nommées column_0 , column_1 , column_2 , et ainsi de suite, en commençant toujours par 0 .
Nous pouvons voir que chaque ROW() La clause de constructeur de ligne crée une nouvelle ligne dans la table résultante.
Chaque ROW() contient une liste de valeurs d'une ou plusieurs valeurs scalaires entre parenthèses. Une valeur peut être un littéral de n'importe quel type de données MySQL ou une expression qui se résout en une valeur scalaire.
Par conséquent, nous pouvons également effectuer les opérations suivantes :
VALUES ROW("Black", "Cat"), ROW("Yellow", "Dog");Résultat :
+----------+----------+ | column_0 | column_1 | +----------+----------+ | Black | Cat | | Yellow | Dog | +----------+----------+
Ou des trucs comme ça :
VALUES
ROW(CURDATE(), DATE_ADD(CURDATE(), INTERVAL 10 YEAR)),
ROW(CURTIME(), DATE_ADD(CURTIME(), INTERVAL 2 HOUR));Résultat :
+---------------------+---------------------+ | column_0 | column_1 | +---------------------+---------------------+ | 2022-02-17 00:00:00 | 2032-02-17 00:00:00 | | 2022-02-17 09:30:46 | 2022-02-17 11:30:46 | +---------------------+---------------------+
Le ORDER BY Article
La syntaxe permet l'utilisation du ORDER BY clause pour ordonner les résultats. Cependant, j'ai trouvé que le ORDER BY La clause ne fonctionne pas comme prévu sur les systèmes sur lesquels j'ai essayé de l'exécuter.
Voici comment cela devrait travail (selon la documentation MySQL):
VALUES ROW(1,-2,3), ROW(5,7,9), ROW(4,6,8) ORDER BY column_1;Résultat :
+----------+----------+----------+ | column_0 | column_1 | column_2 | +----------+----------+----------+ | 1 | -2 | 3 | | 4 | 6 | 8 | | 5 | 7 | 9 | +----------+----------+----------+
Mais sur les deux systèmes sur lesquels j'ai exécuté cette instruction (MySQL 8.0.26 sur Ubuntu 20.04.3 et MySQL 8.0.27 Homebrew sur MacOS Monterery), le ORDER BY clause ne fonctionne pas du tout. C'est peut-être un bug.
La LIMIT Article
Nous pouvons utiliser le LIMIT clause pour limiter le nombre de lignes générées :
VALUES
ROW('Black', 'Cat'),
ROW('Yellow', 'Dog'),
ROW('Aqua', 'Fish')
LIMIT 2;Résultat :
+----------+----------+ | column_0 | column_1 | +----------+----------+ | Black | Cat | | Yellow | Dog | +----------+----------+
Avec un SELECT Déclaration
Nous pouvons également utiliser les VALUES instruction dans un SELECT déclaration, comme si les VALUES constructeur de table était une table réelle :
SELECT
PetName,
PetType
FROM
(VALUES
ROW(1, "Fluffy", "Cat"),
ROW(2, "Bark", "Dog"),
ROW(3, "Gallop", "Horse")
) AS Pets(PetId, PetName, PetType)
WHERE PetId = 2;Résultat :
+---------+---------+ | PetName | PetType | +---------+---------+ | Bark | Dog | +---------+---------+
ROW() Ne peut pas être vide
Un constructeur de ligne ne peut pas être vide, sauf s'il est utilisé comme source dans un INSERT déclaration.
Voici ce qui se passe si nous essayons d'utiliser un constructeur de ligne vide :
VALUES ROW();Résultat :
ERROR 3942 (HY000): Each row of a VALUES clause must have at least one column, unless when used as source in an INSERT statement.
ROW() Peut contenir des valeurs nulles
Bien que les constructeurs de lignes ne puissent pas être vides, ils peuvent contenir des valeurs Null :
VALUES ROW(null, null);Résultat :
+----------+----------+ | column_0 | column_1 | +----------+----------+ | NULL | NULL | +----------+----------+
Chaque ROW() Doit contenir le même nombre de valeurs
Chaque ROW() dans le même VALUES l'instruction doit avoir le même nombre de valeurs dans sa liste de valeurs.
Par conséquent, nous ne pouvons pas faire ceci :
VALUES ROW(1, 2), ROW(3);Résultat :
ERROR 1136 (21S01): Column count doesn't match value count at row 2
Utilisation de VALUES pour insérer des données
Nous pouvons utiliser les VALUES déclaration en conjonction avec le INSERT et REPLACE instructions pour insérer des données dans une table.
Exemple :
INSERT INTO Pets VALUES
ROW(9, 3, 1, 'Woof', '2020-10-03'),
ROW(10, 4, 5, 'Ears', '2022-01-11');
Cela a inséré deux lignes dans une table appelée Pets . Cela suppose que la table existe déjà.
Nous pouvons maintenant utiliser un SELECT pour voir les nouvelles valeurs dans le tableau :
SELECT * FROM Pets
WHERE PetId IN (9, 10);Résultat :
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 9 | 3 | 1 | Woof | 2020-10-03 | | 10 | 4 | 5 | Ears | 2022-01-11 | +-------+-----------+---------+---------+------------+
Le INSERT ci-dessus équivaut à faire ce qui suit :
INSERT INTO Pets VALUES
(9, 3, 1, 'Woof', '2020-10-03'),
(10, 4, 5, 'Ears', '2022-01-11');Lors de la création de tableaux
Les VALUES peut également être utilisée à la place de la table source dans CREATE TABLE … SELECT et CREATE VIEW … SELECT déclarations.
Voici un exemple :
CREATE TABLE t1 VALUES ROW(1,2,3), ROW(4,5,6);
SELECT * FROM t1;Résultat :
+----------+----------+----------+ | column_0 | column_1 | column_2 | +----------+----------+----------+ | 1 | 2 | 3 | | 4 | 5 | 6 | +----------+----------+----------+
Nous pouvons également faire ceci :
CREATE TABLE t2 SELECT * FROM (VALUES ROW(1,2,3), ROW(4,5,6)) AS v;
SELECT * FROM t2;Résultat :
+----------+----------+----------+ | column_0 | column_1 | column_2 | +----------+----------+----------+ | 1 | 2 | 3 | | 4 | 5 | 6 | +----------+----------+----------+
Ces deux CREATE TABLE les déclarations ressemblent à ceci :
CREATE TABLE t3 SELECT * FROM t2;
SELECT * FROM t3;Résultat :
+----------+----------+----------+ | column_0 | column_1 | column_2 | +----------+----------+----------+ | 1 | 2 | 3 | | 4 | 5 | 6 | +----------+----------+----------+
Dans ce cas, j'ai utilisé le t2 table comme table source, au lieu de fournir les valeurs dans un VALUES déclaration.
