MySQL Infoga kommando vs T-SQL frågesyntax med exempel

Utvecklare är livslånga studenter. Att skaffa ny kunskap så fort vi kan är alltid vår spelning. Om du kommer från T-SQL-lägret, vad är det snabbare sättet att lära dig MySQL? Ofta vill man jämföra syntaxer. Förra gången lärde du dig att skapa en tabell i MySQL. Dagens inlägg tar dig ett steg längre. Vi infogar poster med MySQL INSERT.

Hur lätt kan det vara? Båda databasplattformarna använder SQL, men vi vet att båda dessa databasprodukter har sina få tillägg till standard SQL-syntax. MySQL INSERT är inget undantag.

Således, om du är trött på att jämföra referenser för MySQL och SQL Server, är idag din lyckodag. Jag har kurerat syntaxen och gjort jämförelsen åt dig. Vi kommer också att ha exempel att kolla in. Äntligen har vi ytterligare ett gratis fuskblad.

Nu, innan vi dyker in, kan du också få ett GRATIS PDF-fuskblad om den här artikeln genom att fylla i anmälningsformuläret nedan.

[sendpulse-form id="12097″]

Redo? Bra!

MySQL INFOGA I frågesyntax (tabellvärdeskonstruktörer)

Men innan vi går in i detaljerna, låt oss klargöra några saker:

• MySQL-versionen jag använder här är 8.0.23, med InnoDB-lagringsmotorn.
• SQL Server-versionen är 2019.

Låt oss först försöka infoga en post i en tabell. Den grundläggande syntaxen liknar den för SQL Server. Men det är det om du inte inkluderar databasen och schemanamnet och inte omger kolumnnamnen med 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');

Att ange den faktiska platsen för tabellen kommer att vara något annorlunda. Som jag har antytt i det här inlägget är en databas synonymt med ett schema i MySQL. Kontrollera det modifierade exemplet nedan:

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

Har du märkt avsaknaden av schemanamnet ovan?

Samtidigt bildar VALUES-satsen ovan en tabellvärdekonstruktor. På samma sätt har SQL Server den funktionen också.

Infoga flera rader i tabeller i MySQL

Låt oss försöka infoga flera rader.

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');

Ovanstående kod kommer att infoga två poster med två tabellvärdekonstruktorer. Du kan också använda uttryck istället för bokstavliga värden. I exemplet nedan används en underfråga för varje kolumn:

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));

Underfrågorna ser överflödiga ut i frågan ovan. Men detta kommer att generera ett fel:

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!

Tabellvärdeskonstruktorn förväntar sig en bokstavlig eller ett uttryck för varje fält i kolumnlistan. Dessutom returnerar underfrågorna i föregående exempel en enda rad med ett värde, och det är giltigt. Men SELECT-satsen ovan kommer att utlösa ett fel eftersom den returnerar flera rader och kolumner.

Ett annat alternativ är att ange nyckelordet ROW som i exemplet nedan:

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');

Men nyckelordet ROW i INSERT-satsen stöds inte i SQL Server.

MySQL INSERT INTO med SELECT från en annan tabell

Du kan lägga till poster i en tabell med hjälp av SELECT-satsen:

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

Som du kan se är det samma sak med T-SQL utan databasnamn, schemanamn och backtick-tecken. Rang är förresten ett reserverat ord.

Därför är backtick-tecken som omsluter ordet Rank ett måste.

Du kan uttrycka det utan kolumnlistan. Ange helt enkelt kolumnnamnen i samma ordning som måltabellens kolumnuppställning.

TRUNCATE TABLE testdatabase.people2;

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

SELECT * FROM testdatabase.people2

Se utdata nedan från dbForge Studio för MySQL:

Låter bra? Låt oss utveckla mer om ämnet hantering av kolumnvärden.

INSERT och tabeller kolumnvärden

Det här avsnittet kommer att gräva djupare i kolumnvärden när du använder MySQL INSERT. Det finns fyra av dem:

• Unicode-värden.
• Standardvärden.
• Använder automatisk inkrement.
• Värden från de användardefinierade variablerna.

Infoga Unicode-sträng

I T-SQL är du bekant med att föregå ett strängvärde med N . När du använder det antar SQL Server att värdet är ett Unicode-värde. I MySQL behöver du inte det.

Kolla in exemplet nedan:

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

Det finns några punkter att notera:

1. Att använda NVARCHAR för att skapa en tabell i MySQL 8 kommer automatiskt att ändras till VARCHAR.
2. Det finns inget behov av att föregå Unicode-värdet med N , som N’김지수’.
3. Du måste redigera ovanstående kod lite för att den ska köras framgångsrikt i SQL Server.

Kontrollera resultatet nedan:

Här är motsvarande kod i 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

Försök att ta bort "N" från ett av Unicode-värdena ovan. Koden kommer att fungera bra, men du kontrollerar utdata nedan i SQL Server Management Studio:

Hur man infogar standardvärde i MySQL

Kolumnens standardvärden fungerar när du infogar en post utan att ange ett värde. Vi använde det i det första exemplet ovan. Här är kolumndefinitionen igen:

`ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP()

Kolumnen ModifiedDate förinställer aktuellt datum och tid på servern. Det var därför när vi gjorde det här:

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

Resultatet är detta:

Mycket snyggt och sparar på tangenttryckningar. Samma beteende händer även i SQL Server.

Under tiden, om du vill göra det explicit, ange bara kolumnnamnet med värdet DEFAULT:

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

Det fungerar även i SQL Server med en liten modifiering.

Det finns en annan tid och tangenttryckningssparare. Den har ett kolumnvärde för autoinkrement.

INSERT in AUTO_INCREMENT-kolumnen

Istället för att få det sista heltalsvärdet i en tabell och lägga till 1, är det bättre att definiera en kolumn för autoinkrement. det är bra för primärnycklar. Vi gjorde det i Unicode-tabellexemplet.

Här är en del av det igen:

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

Samtidigt använder vi sökordet IDENTITY i SQL Server istället för AUTO_INCREMENT.

Figur 2 visar resultatet av att definiera en autoinkrementkolumn. Heltalsvärdena genererades utan att ange det i INSERT-satsen.

Använda användardefinierade variabler för att ställa in kolumnvärden

Ett annat vanligt fall för att infoga poster i T-SQL är att använda användardefinierade variabler för att ställa in kolumnvärden. Det är användbart för att skapa ad-hoc-skript och lagrade procedurer.

Men först kan man definiera variabler i MySQL med hjälp av SET. Till skillnad från i SQL Server använder du DECLARE. Ta en titt på exemplet:

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);

Som du kan se ovan fungerar variablerna som uttryck för att fylla kolumnvärdena i VALUES-satsen.

Infoga i tillfällig tabell i MySQL

Här granskar vi att använda MySQL INSERT i temporära tabeller. T-SQL-utvecklare är bekanta med "# ’ symbol före ett temporärt tabellnamn. I MySQL skapas temporära tabeller med CREATE TEMPORARY TABLE tabellnamn . Den har inte "# ’ symbol. Därför, bland raderna i ditt skript, kan ett tillfälligt tabellnamn se ut på samma sätt som vanliga tabellnamn:

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;

Med andra ord, att infoga poster i tillfälliga tabeller ser ut på samma sätt som vanliga tabeller.

Här är resultatet:

MySQL INSERT...PÅ DUPLIKATNYCKELUPPDATERING – Syntax som inte stöds i T-SQL

Slutligen har MySQL INSERT syntaxfall som inte stöds i T-SQL. En av dem är INFOGA ... PÅ UPPDATERING AV DUBLIKATNYCKEL. Vad kan det göra?

När en tabell har en unik nyckel och du råkar infoga ett värde som kommer att orsaka en dubblett, kommer INSERT att misslyckas. Men när du använder INSERT...ON DUPLICATE KEY UPDATE kommer en uppdatering av den befintliga raden att ske istället. Felet kommer inte att uppstå.

Låt oss säga att vi har dessa poster i folket tabell:

Lägg märke till värdet på fartygsregistret i rött, och hela raden. Saken är den att vi kommer att infoga samma post med PÅ DUBLIKAT UPPDATERING AV NYCKEL.

Låt oss nu avfyra uttalandet nedan:

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;

Finns det ett fel? Låt oss kolla det!

Coolt, eller hur?

Samma effekt inträffar när du gör detta:

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

Under tiden kan du uttrycka avsikten i T-SQL så här:

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);

Samma resultat kommer att inträffa.

Slutsats

Benjamin Franklin sa en gång:"En investering i kunskap ger alltid bästa intresse." Jag hoppas att den här artikeln kommer att löna sig för dig i tid.

Låt oss ha en sammanfattning:

1. Den grundläggande MySQL INSERT-syntaxen är nästan densamma i T-SQL förutom frånvaron av schemanamnet och användningen av backticks.
2. Att infoga poster i MySQL från en annan tabell är nästan samma sak som i T-SQL.
3. Kolumnvärden hanteras på olika sätt i MySQL INSERT. Unicode-värden är de mest anmärkningsvärda. Syntaxen är också annorlunda vid användning av AUTO_INCREMENT.
4. Att infoga poster i en temporär tabell i MySQL har en mindre skillnad i T-SQL med "# symbol.
5. INSERT...PÅ DUPLIKATNYCKELUPPDATERING ser bra ut när det gäller att förkorta syntaxen för att undvika dubbletter av fel.

Jag hoppas att artikeln visade sig vara användbar för dig medan du lär dig MySQL. Om du gillar det här inlägget, vänligen dela det på dina favoritplattformar för sociala medier!