sql >> Database >  >> RDS >> Mysql

MySQL-opdracht invoegen versus T-SQL-querysyntaxis met voorbeelden

Ontwikkelaars zijn levenslange studenten. Zo snel mogelijk nieuwe kennis opdoen is altijd ons werk. Als je uit het T-SQL-kamp komt, wat is dan de snelste manier om MySQL te leren? Vaak wil je syntaxis vergelijken. De vorige keer heb je geleerd over het maken van een tabel in MySQL. Ons bericht van vandaag brengt je een stap verder. We voegen records in met MySQL INSERT.

Hoe gemakkelijk kan het zijn? Beide databaseplatforms gebruiken SQL, maar we weten dat beide databaseproducten hun weinige toevoegingen hebben aan de standaard SQL-syntaxis. MySQL INSERT is geen uitzondering.

Dus als je moe bent van het vergelijken van referenties voor MySQL en SQL Server, dan is vandaag je geluksdag. Ik heb de syntaxis samengesteld en de vergelijking voor je gemaakt. We zullen ook voorbeelden hebben om te bekijken. Eindelijk hebben we nog een gratis spiekbriefje.

Nu, voordat we erin duiken, kun je ook een GRATIS pdf-spiekbriefje over dit artikel krijgen door het onderstaande aanmeldingsformulier in te vullen.

[sendpulse-form id=”12097″]

Klaar? Geweldig!

MySQL INSERT INTO Query-syntaxis (tabelwaardenconstructors)

Maar voordat we in de details duiken, laten we een paar dingen duidelijk maken:

  • De MySQL-versie die ik hier gebruik is 8.0.23, met de InnoDB-opslagengine.
  • De SQL Server-versie is 2019.

Laten we eerst proberen één record in een tabel in te voegen. De basissyntaxis is vergelijkbaar met die voor SQL Server. Dit is echter het geval als u de database- en schemanaam niet opneemt en de kolomnamen niet met backticks omsluit.

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

Het specificeren van de werkelijke locatie van de tafel zal iets anders zijn. Zoals ik in dit bericht heb aangegeven, is een database synoniem met een schema in MySQL. Bekijk het aangepaste voorbeeld hieronder:

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

Is het je opgevallen dat de bovenstaande schemanaam ontbreekt?

Ondertussen vormt de VALUES-clausule hierboven een tabelwaardeconstructor. Evenzo heeft SQL Server die functie ook.

Meerdere rijen in tabellen in MySQL invoegen

Laten we proberen meerdere rijen in te voegen.

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

De bovenstaande code voegt twee records in met behulp van twee tabelwaardeconstructors. U kunt ook uitdrukkingen gebruiken in plaats van letterlijke waarden. Het onderstaande voorbeeld gebruikt een subquery voor elke kolom:

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

De subquery's lijken overbodig in de bovenstaande query. Maar dit zal een fout genereren:

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!

De tabelwaardeconstructor verwacht een letterlijke of een uitdrukking voor elk veld in de kolomlijst. Bovendien retourneren de subquery's in het vorige voorbeeld een enkele rij met één waarde, en dat is geldig. De bovenstaande SELECT-instructie zal echter een fout activeren omdat deze meerdere rijen en kolommen retourneert.

Een andere optie is om het ROW-trefwoord op te geven, zoals in het onderstaande voorbeeld:

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

Maar het ROW-sleutelwoord in de INSERT-instructie wordt niet ondersteund in SQL Server.

MySQL INSERT INTO met SELECT uit een andere tabel

U kunt records aan een tabel toevoegen met behulp van de SELECT-instructie:

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

Zoals je kunt zien, is het hetzelfde met T-SQL zonder de databasenaam, schemanaam en het backtick-teken. Rang is trouwens een gereserveerd woord.

Daarom zijn de backtick-tekens die het woord Rang bevatten een must.

Je kunt het uitdrukken zonder de kolomlijst. Specificeer eenvoudig de kolomnamen in dezelfde volgorde als de kolomindeling van de doeltabel.

TRUNCATE TABLE testdatabase.people2;

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

SELECT * FROM testdatabase.people2

Zie de output hieronder van dbForge Studio voor MySQL:

Klinkt goed? Laten we dieper ingaan op het onderwerp van het omgaan met kolomwaarden.

INSERT en tabellen kolomwaarden

In deze sectie wordt dieper ingegaan op kolomwaarden bij het gebruik van MySQL INSERT. Er zijn er vier:

  • Unicode-waarden.
  • Standaardwaarden.
  • Automatisch verhogen gebruiken.
  • Waarden van de door de gebruiker gedefinieerde variabelen.

Unicode-tekenreeks invoegen

In T-SQL bent u bekend met het voorafgaan van een tekenreekswaarde met N . Bij gebruik daarvan gaat de SQL Server ervan uit dat de waarde een Unicode-waarde is. In MySQL heb je dat niet nodig.

Bekijk het onderstaande voorbeeld:

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

Er zijn een paar punten om op te letten:

  1. NVARCHAR gebruiken bij het maken van een tabel in MySQL 8 wordt automatisch gewijzigd in VARCHAR.
  2. Het is niet nodig om de Unicode-waarde vooraf te laten gaan door N , zoals N’김지수’.
  3. Je moet de bovenstaande code een beetje aanpassen om het succesvol te laten werken in SQL Server.

Bekijk het resultaat hieronder:

Hier is de equivalente code in 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

Probeer de 'N' uit een van de bovenstaande Unicode-waarden te verwijderen. De code zal goed werken, maar je controleert de output hieronder in SQL Server Management Studio:

Standaardwaarde invoegen in MySQL

De standaardwaarden van de kolom werken wanneer u een record invoegt zonder een waarde op te geven. Dat hebben we in het eerste voorbeeld hierboven gebruikt. Hier is nogmaals de kolomdefinitie:


`ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP()

De kolom ModifiedDate standaard ingesteld op de huidige datum en tijd op de server. Daarom deden we dit:

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

Het resultaat is dit:

Heel netjes en besparend op toetsaanslagen. Hetzelfde gedrag doet zich ook voor in SQL Server.

Als u het ondertussen expliciet wilt maken, geeft u de kolomnaam op met de waarde DEFAULT:

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

Het werkt ook in SQL Server met een kleine wijziging.

Er is een andere tijd- en toetsaanslagbesparing. Het heeft een kolomwaarde voor automatisch verhogen.

INSERT in AUTO_INCREMENT Kolom

In plaats van de laatste integer-waarde op een tabel te krijgen en 1 toe te voegen, is het beter om een ​​auto-increment-kolom te definiëren. het is goed voor primaire sleutels. Dat hebben we gedaan in het voorbeeld van de Unicode-tabel.

Hier is nog een deel ervan:

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

Ondertussen gebruiken we in SQL Server het trefwoord IDENTITY in plaats van AUTO_INCREMENT.

Figuur 2 laat het resultaat zien van het definiëren van een auto-increment-kolom. De integer-waarden zijn gegenereerd zonder deze te specificeren in de INSERT-instructie.

Gebruikergedefinieerde variabelen gebruiken om kolomwaarden in te stellen

Een ander veelvoorkomend geval voor het invoegen van records in T-SQL is het toepassen van door de gebruiker gedefinieerde variabelen om kolomwaarden in te stellen. Het is handig voor het maken van ad-hocscripts en opgeslagen procedures.

Maar eerst kunnen variabelen in MySQL worden gedefinieerd met SET. In tegenstelling tot SQL Server gebruik je DECLARE. Bekijk het voorbeeld:

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

Zoals u hierboven kunt zien, fungeren de variabelen als uitdrukkingen om de kolomwaarden in de VALUES-clausule te vullen.

Invoegen in tijdelijke tabel in MySQL

Hier bespreken we het gebruik van MySQL INSERT in tijdelijke tabellen. T-SQL-ontwikkelaars zijn bekend met de '# ' symbool voorafgaand aan een tijdelijke tabelnaam. In MySQL worden tijdelijke tabellen gemaakt met CREATE TEMPORARY TABLE table_name . Het heeft niet de '# ' symbool. Daarom kan een tijdelijke tabelnaam tussen de regels van uw script er hetzelfde uitzien als normale tabelnamen:

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;

Met andere woorden, het invoegen van records in tijdelijke tabellen ziet er hetzelfde uit als gewone tabellen.

Dit is het resultaat:

MySQL INSERT...ON DUPLICATE KEY UPDATE - Niet-ondersteunde syntaxis in T-SQL

Ten slotte heeft MySQL INSERT syntaxisgevallen die niet worden ondersteund in T-SQL. Een daarvan is INSERT...ON DUPLICATE KEY UPDATE. Wat kan het?

Wanneer een tabel een unieke sleutel heeft en u een waarde invoert die een duplicaat veroorzaakt, zal de INSERT mislukken. Wanneer u echter INSERT...ON DUPLICATE KEY UPDATE gebruikt, zal in plaats daarvan een update van de bestaande rij plaatsvinden. De fout zal niet optreden.

Laten we zeggen dat we deze records hebben in de mensen tafel:

Let op de waarde van het scheepsregister in rood omkaderd, en die hele regel. Het punt is dat we hetzelfde record gaan invoegen met ON DUPLICATE KEY UPDATE.

Laten we nu de onderstaande verklaring afvuren:

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;

Is er een fout? Laten we eens kijken!

Cool, nietwaar?

Hetzelfde effect gebeurt wanneer u dit doet:

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

Ondertussen kun je de intentie in T-SQL als volgt uitdrukken:

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

Hetzelfde resultaat zal optreden.

Conclusie

Benjamin Franklin zei ooit:"Een investering in kennis betaalt altijd de beste rente." Ik hoop dat dit artikel op tijd zijn vruchten zal afwerpen.

Laten we het even samenvatten:

  1. De basissyntaxis van MySQL INSERT is bijna hetzelfde in T-SQL, behalve de afwezigheid van de schemanaam en het gebruik van backticks.
  2. Het invoegen van records in MySQL vanuit een andere tabel is bijna hetzelfde als in T-SQL.
  3. Kolomwaarden worden anders behandeld in MySQL INSERT. Unicode-waarden zijn het meest opvallend. Ook is de syntaxis anders bij het gebruik van AUTO_INCREMENT.
  4. Het invoegen van records in een tijdelijke tabel in MySQL heeft een klein verschil in T-SQL met de '# ' symbool.
  5. INSERT...ON DUPLICATE KEY UPDATE ziet er goed uit door de syntaxis in te korten om dubbele fouten te voorkomen.

Ik hoop dat het artikel nuttig voor je is geweest terwijl je MySQL aan het leren bent. Als je dit bericht leuk vindt, deel het dan op je favoriete sociale mediaplatforms!


  1. Een schuifbaar, bijwerkbaar ResultSet-object maken in JDBC

  2. Gegevens visualiseren

  3. MySQL vs. MariaDB:wat u moet weten

  4. Opgeslagen procedure om informatie over databasetabellen te krijgen