Mysql
 sql >> Base de données >  >> RDS >> Mysql

Commande d'insertion MySQL vs syntaxe de requête T-SQL avec exemples

Les développeurs sont des étudiants à vie. Acquérir de nouvelles connaissances aussi vite que possible est toujours notre boulot. Si vous venez du camp T-SQL, quel est le moyen le plus rapide d'apprendre MySQL ? Souvent, vous souhaitez comparer des syntaxes. La dernière fois, vous avez appris à créer une table dans MySQL. Notre article d'aujourd'hui vous emmènera un peu plus loin. Nous allons insérer des enregistrements avec MySQL INSERT.

À quel point cela peut-il être facile ? Les deux plates-formes de base de données utilisent SQL, mais nous savons que ces deux produits de base de données ont leurs quelques ajouts à la syntaxe SQL standard. MySQL INSERT ne fait pas exception.

Ainsi, si vous en avez assez de comparer des références pour MySQL et SQL Server, c'est aujourd'hui votre jour de chance. J'ai organisé la syntaxe et fait la comparaison pour vous. De plus, nous aurons des exemples à vérifier. Enfin, nous aurons une autre feuille de triche gratuite.

Maintenant, avant de plonger, vous pouvez également obtenir une feuille de triche PDF GRATUITE sur cet article en remplissant le formulaire d'inscription ci-dessous.

[sendpulse-form id="12097″]

Prêt? Génial !

Syntaxe de requête MySQL INSERT INTO (constructeurs de valeurs de table)

Mais avant de plonger dans les détails, clarifions quelques points :

  • La version de MySQL que j'utilise ici est la 8.0.23, avec le moteur de stockage InnoDB.
  • La version de SQL Server est 2019.

Essayons d'abord d'insérer un enregistrement dans une table. La syntaxe de base est similaire à celle de SQL Server. Cependant, c'est le cas si vous n'incluez pas le nom de la base de données et du schéma et si vous n'entourez pas les noms de colonne de backticks.

CREATE TABLE testdatabase.people
(`ID` int NOT NULL PRIMARY KEY,
 `Lastname` varchar(50) NOT NULL,
 `FirstName` varchar(50) NOT NULL,
 `MiddleName` varchar(50) NULL DEFAULT '',
 `Rank` varchar(20) NOT NULL,
 `Ship` varchar(50) NOT NULL,
 `ShipRegistry` varchar(20) NOT NULL,
 `ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP());
  
INSERT INTO people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (3,'Archer','Jonathan','','Captain','Enterprise','NX-01');

Spécifier l'emplacement réel de la table sera légèrement différent. Comme je l'ai indiqué dans cet article, une base de données est synonyme de schéma dans MySQL. Vérifiez l'exemple modifié ci-dessous :

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (3,'Archer','Jonathan','','Captain','Enterprise','NX-01');

Avez-vous remarqué l'absence du nom du schéma ci-dessus ?

Pendant ce temps, la clause VALUES ci-dessus forme un constructeur de valeur de table. De même, SQL Server possède également cette fonctionnalité.

Insérer plusieurs lignes dans des tables dans MySQL

Essayons d'insérer plusieurs lignes.

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName, Rank, Ship, ShipRegistry)
VALUES (4,'Janeway','Kathryn','', Captain','USS Voyager', 'NCC-74656'), 
       (5, 'Sisko','Benjamin','','Captain','USS Defiant','NX-74205');

Le code ci-dessus insérera deux enregistrements à l'aide de deux constructeurs de valeurs de table. Vous pouvez également utiliser des expressions au lieu de valeurs littérales. L'exemple ci-dessous utilise une sous-requête pour chaque colonne :

CREATE TABLE testdatabase.people2 LIKE people;

INSERT INTO testdatabase.people2
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (4,'Janeway','Kathryn','','Captain','USS Voyager', 'NCC-74656'), 
       (5, (SELECT Lastname FROM people WHERE ID=5), 
           (SELECT Firstname FROM people WHERE ID=5), 
           (SELECT MiddleName FROM people WHERE ID=5),
           (SELECT `Rank` FROM people WHERE ID=5),
           (SELECT Ship FROM people WHERE ID=5),
           (SELECT ShipRegistry FROM people WHERE ID=5));

Les sous-requêtes semblent redondantes dans la requête ci-dessus. Mais cela va générer une erreur :

INSERT INTO testdatabase.people2
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (4,'Janeway','Kathryn','','Captain','USS Voyager', 'NCC-74656'), 
       (SELECT `ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, 
        `Ship`, `ShipRegistry` FROM people);    -- ERROR!

Le constructeur de valeur de table attend un littéral ou une expression pour chaque champ de la liste de colonnes. De plus, les sous-requêtes de l'exemple précédent renvoient une seule ligne avec une valeur, et c'est valide. Cependant, l'instruction SELECT ci-dessus déclenchera une erreur car elle renvoie plusieurs lignes et colonnes.

Une autre option consiste à spécifier le mot-clé ROW comme dans l'exemple ci-dessous :

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName, Rank, Ship, ShipRegistry)
VALUES ROW(4,'Janeway','Kathryn','', Captain','USS Voyager', 'NCC-74656'), 
       ROW(5, 'Sisko','Benjamin','','Captain','USS Defiant','NX-74205');

Mais le mot clé ROW dans l'instruction INSERT n'est pas pris en charge dans SQL Server.

MySQL INSERT INTO avec SELECT d'une autre table

Vous pouvez ajouter des enregistrements dans une table à l'aide de l'instruction SELECT :

INSERT INTO people2
(ID, Lastname, FirstName, MiddleName, `Rank`, Ship, ShipRegistry)
SELECT ID, Lastname, FirstName, MiddleName, `Rank`, Ship, ShipRegistry FROM people;

Comme vous pouvez le voir, c'est la même chose avec T-SQL sans le nom de la base de données, le nom du schéma et le caractère de backtick. Le rang est un mot réservé, soit dit en passant.

Par conséquent, les caractères de backtick entourant le mot Rank sont indispensables.

Vous pouvez l'exprimer sans la liste des colonnes. Spécifiez simplement les noms de colonne dans le même ordre que la disposition des colonnes de la table cible.

TRUNCATE TABLE testdatabase.people2;

INSERT INTO testdatabase.people2
SELECT ID, Lastname, FirstName, MiddleName, `Rank`, Ship, ShipRegistry, ModifiedDate 
FROM people;

SELECT * FROM testdatabase.people2

Voir la sortie ci-dessous de dbForge Studio pour MySQL :

Ça a l'air bien? Élaborons davantage sur le sujet de la gestion des valeurs de colonne.

INSERT et valeurs des colonnes des tableaux

Cette section approfondira les valeurs des colonnes lors de l'utilisation de MySQL INSERT. Il y en a quatre :

  • Valeurs Unicode.
  • Valeurs par défaut.
  • Utilisation de l'auto-incrémentation.
  • Valeurs des variables définies par l'utilisateur.

Insérer une chaîne Unicode

Dans T-SQL, vous êtes habitué à faire précéder une valeur de chaîne par N . Lorsque vous l'utilisez, SQL Server suppose que la valeur est une valeur Unicode. Dans MySQL, vous n'en avez pas besoin.

Découvrez l'exemple ci-dessous :

CREATE TABLE IF NOT EXISTS UnicodeNames
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 FullName varchar(50) NOT NULL);

INSERT INTO UnicodeNames
(FullName)
VALUES ('김지수'),('김제니'),('박채영'),('ลลิษา มโนบาล');

SELECT * FROM UnicodeNames

Il y a quelques points à prendre en compte :

  1. L'utilisation de NVARCHAR lors de la création d'une table dans MySQL 8 sera automatiquement remplacée par VARCHAR.
  2. Il n'est pas nécessaire de faire précéder la valeur Unicode de N , comme N'김지수'.
  3. Vous devez modifier légèrement le code ci-dessus pour qu'il s'exécute correctement dans SQL Server.

Vérifiez le résultat ci-dessous :

Voici le code équivalent en T-SQL :

CREATE TABLE UnicodeNames
(ID int NOT NULL IDENTITY PRIMARY KEY,
 FullName nvarchar(50) NOT NULL);

INSERT INTO UnicodeNames
(FullName)
VALUES (N'김지수'),(N'김제니'),(N'박채영'),(N'ลลิษา มโนบาล');

SELECT * FROM UnicodeNames

Essayez de supprimer le "N" de l'une des valeurs Unicode ci-dessus. Le code fonctionnera correctement, mais vous vérifiez la sortie ci-dessous dans SQL Server Management Studio :

Comment insérer une valeur par défaut dans MySQL

Les valeurs par défaut de la colonne agissent lorsque vous insérez un enregistrement sans spécifier de valeur. Nous l'avons utilisé dans le premier exemple ci-dessus. Voici à nouveau la définition de la colonne :


`ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP()

La colonne ModifiedDate par défaut la date et l'heure actuelles sur le serveur. C'est pourquoi nous avons fait ceci :

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (3,'Archer','Jonathan','','Captain','Enterprise','NX-01');

Le résultat est le suivant :

Très soigné et économisant sur les frappes. Ce même comportement se produit également dans SQL Server.

En attendant, si vous voulez le rendre explicite, spécifiez simplement le nom de la colonne avec la valeur DEFAULT :

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`, `ModifiedDate`)
VALUES (6, 'Pyke','Christopher','','Captain','USS Enterprise','NCC 1701', DEFAULT);

Cela fonctionne également dans SQL Server avec une légère modification.

Il existe un autre économiseur de temps et de frappe. Il a une valeur de colonne d'auto-incrémentation.

INSÉRER dans Colonne AUTO_INCREMENT

Au lieu d'obtenir la dernière valeur entière d'une table et d'ajouter 1, il est préférable de définir une colonne d'auto-incrémentation. c'est bon pour les clés primaires. Nous l'avons fait dans l'exemple de table Unicode.

En voici à nouveau une partie :

CREATE TABLE IF NOT EXISTS UnicodeNames
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 FullName varchar(50) NOT NULL);

Pendant ce temps, dans SQL Server, nous utilisons le mot-clé IDENTITY au lieu de AUTO_INCREMENT.

La figure 2 révèle le résultat de la définition d'une colonne d'auto-incrémentation. Les valeurs entières ont été générées sans le spécifier dans l'instruction INSERT.

Utilisation de variables définies par l'utilisateur pour définir des valeurs de colonne

Un autre cas courant d'insertion d'enregistrements dans T-SQL consiste à appliquer des variables définies par l'utilisateur pour définir des valeurs de colonne. Il est utile pour créer des scripts ad hoc et des procédures stockées.

Mais d'abord, la définition de variables dans MySQL peut être effectuée à l'aide de SET. Contrairement à SQL Server, vous utilisez DECLARE. Regardez l'exemple :

SET @stringValue = 'string value';
SET @numericValue = 1287;
SET @booleanValue = TRUE;
SET @dateValue = CURRENT_DATE();

CREATE TABLE IF NOT EXISTS TableDataTypeValues
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 stringValue varchar(50) NOT NULL,
 numericValue int NOT NULL,
 BooleanValue bit not NULL DEFAULT FALSE,
 dateValue date NULL);

INSERT INTO TableDataTypeValues
(stringValue, numericValue, BooleanValue, dateValue)
VALUES (@stringValue, @numericValue, @booleanValue, @dateValue);

Comme vous pouvez le voir ci-dessus, les variables agissent comme des expressions pour remplir les valeurs de colonne dans la clause VALUES.

Insérer dans une table temporaire dans MySQL

Ici, nous passons en revue l'utilisation de MySQL INSERT dans les tables temporaires. Les développeurs T-SQL sont familiers avec le '# ‘ symbole précédant un nom de table temporaire. Dans MySQL, les tables temporaires sont créées à l'aide de CREATE TEMPORARY TABLE table_name . Il n'a pas le '# ' symbole. Par conséquent, parmi les lignes de votre script, un nom de table temporaire peut ressembler à des noms de table normaux :

CREATE TEMPORARY TABLE tmpkpopgroup
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 GroupName varchar(50) NOT NULL,
 ModifiedDate datetime DEFAULT CURRENT_TIMESTAMP());

INSERT INTO tmpkpopgroup
(GroupName)
VALUES ('BTS'),('SEVENTEEN'),('TWICE'),('MOMOLAND'),('GIRLS GENERATION'),('BLACKPINK'),('OH MY GIRL'),('RED VELVET');

SELECT * FROM tmpkpopgroup
ORDER BY GroupName;

En d'autres termes, l'insertion d'enregistrements dans des tables temporaires ressemble à des tables normales.

Voici le résultat :

Insertion MySQL… SUR LA MISE À JOUR DE LA CLÉ EN DOUBLE – Syntaxe non prise en charge dans T-SQL

Enfin, MySQL INSERT a des cas de syntaxe non pris en charge dans T-SQL. L'un d'eux est INSERT… ON DUPLICATE KEY UPDATE. Que peut-il faire ?

Lorsqu'une table a une clé unique et que vous insérez une valeur qui provoquera un doublon, l'INSERT échouera. Cependant, lorsque vous utilisez INSERT… ON DUPLICATE KEY UPDATE, une mise à jour de la ligne existante se produira à la place. L'erreur ne se produira pas.

Disons que nous avons ces enregistrements dans les personnes tableau :

Remarquez la valeur du registre des navires encadrée en rouge, et cette ligne entière. Le fait est que nous allons insérer le même enregistrement avec ON DUPLICATE KEY UPDATE.

Maintenant, lançons la déclaration ci-dessous :

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`, `ModifiedDate`)
VALUES (5, 'Sisko','Benjamin','','Captain','USS Defiant','NCC-75633', DEFAULT)
ON DUPLICATE KEY UPDATE ShipRegistry = 'NCC-75633';

SELECT * FROM testdatabase.people;

Y a-t-il une erreur ? Vérifions !

Cool, n'est-ce pas ?

Le même effet se produit lorsque vous faites ceci :

UPDATE people 
SET ShipRegistry = 'NCC-75633'
WHERE ID = 5

En attendant, vous pouvez exprimer l'intention dans T-SQL comme ceci :

IF EXISTS(SELECT id FROM people WHERE id = 5)
	UPDATE people 
	SET ShipRegistry = 'NCC-75633'
	WHERE ID = 5
ELSE
	INSERT INTO people
	(ID, LastName, FirstName, MiddleName, [Rank], Ship, ShipRegistry, ModifiedDate)
	VALUES (5, 'Sisko','Benjamin','','Captain','USS Defiant','NCC-75633', DEFAULT);

Le même résultat se produira.

Conclusion

Benjamin Franklin a dit un jour :"Un investissement dans la connaissance paie toujours le meilleur intérêt." J'espère que cet article vous rapportera à temps.

Faisons un récapitulatif :

  1. La syntaxe de base de MySQL INSERT est presque la même dans T-SQL, à l'exception de l'absence du nom du schéma et de l'utilisation de backticks.
  2. L'insertion d'enregistrements dans MySQL à partir d'une autre table est presque la même que dans T-SQL.
  3. Les valeurs de colonne sont gérées différemment dans MySQL INSERT. Les valeurs Unicode sont les plus notables. De plus, la syntaxe est différente dans l'utilisation de AUTO_INCREMENT.
  4. L'insertion d'enregistrements dans une table temporaire dans MySQL a une différence mineure dans T-SQL avec le '# ‘ symbole.
  5. INSERT…ON DUPLICATE KEY UPDATE permet de raccourcir la syntaxe pour éviter les erreurs en double.

J'espère que l'article vous a été utile pendant que vous apprenez MySQL. Si vous aimez cet article, partagez-le sur vos plateformes de médias sociaux préférées !