Mysql
 sql >> Database >  >> RDS >> Mysql

MySQL Insert Command vs Sintassi di query T-SQL con esempi

Gli sviluppatori sono studenti per tutta la vita. Acquisire nuove conoscenze il più velocemente possibile è sempre il nostro compito. Se vieni dal campo T-SQL, qual è il modo più veloce per imparare MySQL? Spesso vuoi confrontare le sintassi. L'ultima volta, hai imparato a creare una tabella in MySQL. Il nostro post di oggi ti farà fare un ulteriore passo avanti. Inseriremo i record con MySQL INSERT.

Quanto può essere facile? Entrambe le piattaforme di database utilizzano SQL, ma sappiamo che entrambi questi prodotti di database hanno le loro poche aggiunte alla sintassi SQL standard. MySQL INSERT non fa eccezione.

Quindi, se sei stanco di confrontare i riferimenti per MySQL e SQL Server, oggi è il tuo giorno fortunato. Ho curato la sintassi e fatto il confronto per te. Inoltre, avremo degli esempi da verificare. Infine, avremo un altro cheat sheet gratuito.

Ora, prima di immergerci, puoi anche ottenere un cheat sheet PDF GRATUITO su questo articolo compilando il modulo di adesione qui sotto.

[sendpulse-form id="12097″]

Pronto? Ottimo!

MySQL INSERT INTO Query Syntax (costruttori di valori di tabella)

Ma prima di entrare nei dettagli, chiariamo alcune cose:

  • La versione di MySQL che sto usando qui è la 8.0.23, con il motore di archiviazione InnoDB.
  • La versione di SQL Server è 2019.

Per prima cosa, proviamo a inserire un record in una tabella. La sintassi di base è simile a quella di SQL Server. Tuttavia, lo è se non includi il database e il nome dello schema e non racchiudi i nomi delle colonne con backtick.

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

Specificare la posizione effettiva del tavolo sarà leggermente diverso. Come ho indicato in questo post, un database è sinonimo di uno schema in MySQL. Controlla l'esempio modificato di seguito:

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

Hai notato l'assenza del nome dello schema sopra?

Nel frattempo, la clausola VALUES sopra forma un costruttore di valori di tabella. Allo stesso modo, anche SQL Server ha questa funzionalità.

Inserisci più righe nelle tabelle in MySQL

Proviamo a inserire più righe.

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

Il codice precedente inserirà due record utilizzando due costruttori di valori di tabella. Puoi anche usare espressioni invece di valori letterali. L'esempio seguente utilizza una sottoquery per ogni colonna:

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

Le sottoquery sembrano ridondanti nella query precedente. Ma questo genererà un errore:

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!

Il costruttore del valore della tabella prevede un valore letterale o un'espressione per ogni campo nell'elenco delle colonne. Inoltre, le sottoquery nell'esempio precedente restituiscono una singola riga con un valore, e questo è valido. Tuttavia, l'istruzione SELECT sopra attiverà un errore perché restituisce più righe e colonne.

Un'altra opzione è specificare la parola chiave RIGA come nell'esempio seguente:

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

Ma la parola chiave ROW nell'istruzione INSERT non è supportata in SQL Server.

MySQL INSERT INTO con SELECT da un'altra tabella

Puoi aggiungere record in una tabella utilizzando l'istruzione SELECT:

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

Come puoi vedere, è lo stesso con T-SQL senza il nome del database, il nome dello schema e il carattere backtick. Rango è una parola riservata, tra l'altro.

Quindi, i caratteri di backtick che racchiudono la parola Rank sono d'obbligo.

Puoi esprimerlo senza l'elenco delle colonne. Specifica semplicemente i nomi delle colonne nella stessa sequenza della disposizione delle colonne della tabella di destinazione.

TRUNCATE TABLE testdatabase.people2;

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

SELECT * FROM testdatabase.people2

Vedi l'output di seguito da dbForge Studio per MySQL:

Suona bene? Espandiamo ulteriormente l'argomento della gestione dei valori delle colonne.

INSERT e valori delle colonne delle tabelle

Questa sezione approfondirà i valori delle colonne quando si utilizza MySQL INSERT. Ce ne sono quattro:

  • Valori Unicode.
  • Valori predefiniti.
  • Utilizzo dell'incremento automatico.
  • Valori dalle variabili definite dall'utente.

Inserisci stringa Unicode

In T-SQL, hai familiarità con il precedere un valore di stringa con N . Quando lo si utilizza, SQL Server presuppone che il valore sia un valore Unicode. In MySQL, non ne hai bisogno.

Dai un'occhiata all'esempio seguente:

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

Ci sono alcuni punti da tenere in considerazione:

  1. L'utilizzo di NVARCHAR nella creazione di una tabella in MySQL 8 verrà automaticamente modificato in VARCHAR.
  2. Non è necessario far precedere il valore Unicode con N , come N'김지수'.
  3. È necessario modificare leggermente il codice precedente per farlo funzionare correttamente in SQL Server.

Controlla il risultato qui sotto:

Ecco il codice equivalente 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

Prova a rimuovere la "N" da uno dei valori Unicode sopra. Il codice funzionerà correttamente, ma controlla l'output di seguito in SQL Server Management Studio:

Come inserire il valore predefinito in MySQL

I valori predefiniti della colonna agiscono quando si inserisce un record senza specificare un valore. L'abbiamo usato nel primo esempio sopra. Ecco di nuovo la definizione della colonna:


`ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP()

La colonna Data modificata il valore predefinito è la data e l'ora correnti sul server. Ecco perché quando abbiamo fatto questo:

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

Il risultato è questo:

Molto pulito e risparmia sui tasti. Questo stesso comportamento si verifica anche in SQL Server.

Nel frattempo, se vuoi renderlo esplicito, basta specificare il nome della colonna con un valore di DEFAULT:

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

Funziona anche in SQL Server con una leggera modifica.

C'è un altro risparmio di tempo e battitura. Ha un valore di colonna di autoincremento.

INSERIRE in Colonna AUTO_INCREMENT

Invece di ottenere l'ultimo valore intero su una tabella e aggiungere 1, è meglio definire una colonna di incremento automatico. va bene per le chiavi primarie. L'abbiamo fatto nell'esempio della tabella Unicode.

Eccone di nuovo una parte:

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

Nel frattempo, in SQL Server, utilizziamo la parola chiave IDENTITY invece di AUTO_INCREMENT.

La Figura 2 mostra il risultato della definizione di una colonna di autoincremento. I valori interi sono stati generati senza specificarlo nell'istruzione INSERT.

Utilizzo di variabili definite dall'utente per impostare i valori delle colonne

Un altro caso comune per l'inserimento di record in T-SQL è l'applicazione di variabili definite dall'utente per impostare i valori delle colonne. È utile per creare script e procedure memorizzate ad hoc.

Ma prima, la definizione delle variabili in MySQL può essere eseguita usando SET. A differenza di SQL Server, si usa DECLARE. Dai un'occhiata all'esempio:

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

Come puoi vedere sopra, le variabili agiscono come espressioni per riempire i valori delle colonne nella clausola VALUES.

Inserisci nella tabella temporanea in MySQL

Qui, esaminiamo l'utilizzo di MySQL INSERT nelle tabelle temporanee. Gli sviluppatori T-SQL hanno familiarità con "# ' simbolo che precede il nome di una tabella temporanea. In MySQL, le tabelle temporanee vengono create utilizzando CREATE TEMPORARY TABLE nome_tabella . Non ha il "# ' simbolo. Quindi, tra le righe del tuo script, un nome di tabella temporanea può avere lo stesso aspetto dei normali nomi di tabella:

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;

In altre parole, l'inserimento di record nelle tabelle temporanee ha lo stesso aspetto delle tabelle normali.

Ecco il risultato:

INSERIRE MySQL... SU AGGIORNAMENTO CHIAVE DUPLICATA – Sintassi non supportata in T-SQL

Infine, MySQL INSERT ha casi di sintassi non supportati in T-SQL. Uno di questi è INSERT...ON DUPLICATE KEY UPDATE. Cosa può fare?

Quando una tabella ha una chiave univoca e ti capita di inserire un valore che causerà un duplicato, INSERT avrà esito negativo. Tuttavia, quando si utilizza INSERT...ON DUPLICATE KEY UPDATE, si verificherà invece un aggiornamento della riga esistente. L'errore non si verificherà.

Supponiamo di avere questi record nelle persone tabella:

Notare il valore del registro della nave nella casella rossa e l'intera riga. Il fatto è che inseriremo lo stesso record con ON DUPLICATE KEY UPDATE.

Ora, attiviamo la dichiarazione di seguito:

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;

C'è un errore? Controlliamolo!

Fantastico, vero?

Lo stesso effetto si verifica quando lo fai:

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

Nel frattempo, puoi esprimere l'intenzione in T-SQL in questo modo:

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

Si verificherà lo stesso risultato.

Conclusione

Benjamin Franklin una volta disse:"Un investimento nella conoscenza paga sempre il miglior interesse". Spero che questo articolo ti ripaghi in tempo.

Ricapitoliamo:

  1. La sintassi di base di MySQL INSERT è quasi la stessa in T-SQL ad eccezione dell'assenza del nome dello schema e dell'uso di backtick.
  2. L'inserimento di record in MySQL da un'altra tabella è quasi lo stesso che in T-SQL.
  3. I valori delle colonne sono gestiti in modo diverso in MySQL INSERT. I valori Unicode sono i più notevoli. Inoltre, la sintassi è diversa nell'uso di AUTO_INCREMENT.
  4. L'inserimento di record in una tabella temporanea in MySQL presenta una piccola differenza in T-SQL con "# simbolo '.
  5. INSERT...ON DUPLICATE KEY UPDATE sembra buono per abbreviare la sintassi per evitare errori duplicati.

Spero che l'articolo ti sia stato utile mentre stai imparando MySQL. Se ti piace questo post, condividilo sulle tue piattaforme di social media preferite!