Come INSERT se la riga non esiste (UPSERT) in MySQL

• Utilizzo di INSERT IGNORE
• Utilizzo di REPLACE
• Utilizzo di INSERT ... ON DUPLICATE KEY UPDATE

MySQL fornisce una serie di utili istruzioni quando è necessario INSERT righe dopo determinando se quella riga è, in effetti, nuova o già esistente.

Di seguito esamineremo i tre diversi metodi e spiegheremo i pro ei contro di ciascuno a turno in modo da avere una solida conoscenza su come configurare le proprie dichiarazioni quando si forniscono dati nuovi o potenzialmente esistenti per INSERTION .

Utilizzo di INSERT IGNORE

Usando INSERT IGNORE fa sì che MySQL ignori errori di esecuzione durante il tentativo di eseguire INSERT dichiarazioni. Ciò significa che un INSERT IGNORE istruzione che contiene un valore duplicato in un UNIQUE index o PRIMARY KEY campo non produrrà un errore, ma ignorerà semplicemente quel particolare INSERT comandare interamente. Lo scopo ovvio è eseguire un gran numero di INSERT istruzioni per una combinazione di dati già esistenti nel database e nuovi dati in entrata nel sistema.

Ad esempio, i nostri books la tabella potrebbe contenere già alcuni record:

mysql> SELECT * FROM books LIMIT 3;
+----+-------------------------+---------------------+----------------+
| id | title                   | author              | year_published |
+----+-------------------------+---------------------+----------------+
|  1 | In Search of Lost Time  | Marcel Proust       |           1913 |
|  2 | Ulysses                 | James Joyce         |           1922 |
|  3 | Don Quixote             | Miguel de Cervantes |           1605 |
+----+-------------------------+---------------------+----------------+
3 rows in set (0.00 sec)

Se abbiamo una grande quantità di dati nuovi ed esistenti da INSERT e parte di questi dati contiene un valore corrispondente per id campo (che è un UNIQUE PRIMARY_KEY nella tabella), utilizzando un INSERT di base produrrà un errore previsto:

mysql> INSERT INTO books
    (id, title, author, year_published)
VALUES
    (1, 'Green Eggs and Ham', 'Dr. Seuss', 1960);
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'

Se invece utilizziamo INSERT IGNORE , il tentativo di duplicazione viene ignorato e non si verificano errori risultanti:

mysql> INSERT IGNORE INTO books
    (id, title, author, year_published)
VALUES
    (1, 'Green Eggs and Ham', 'Dr. Seuss', 1960);
Query OK, 0 rows affected (0.00 sec)

Utilizzo di REPLACE

Nel caso in cui desideri effettivamente sostituire righe dove INSERT i comandi produrrebbero errori dovuti a UNIQUE duplicati o PRIMARY KEY valori come indicato sopra, un'opzione è optare per REPLACE dichiarazione.

Quando si emette un REPLACE dichiarazione, ci sono due possibili risultati per ogni comando emesso:

• Non è stata trovata alcuna riga di dati esistente con valori corrispondenti e quindi un INSERT standard l'istruzione viene eseguita.
• Una riga di dati corrispondente è trovato, causando l'eliminazione di quella riga esistente con lo standard DELETE istruzione, quindi un normale INSERT viene eseguito in seguito.

Ad esempio, possiamo usare REPLACE per sostituire il nostro record esistente di id = 1 di Alla ricerca del tempo perduto di Marcel Proust con uova verdi e prosciutto del Dr. Seuss:

mysql> REPLACE INTO books
    (id, title, author, year_published)
VALUES
    (1, 'Green Eggs and Ham', 'Dr. Seuss', 1960);
Query OK, 2 rows affected (0.00 sec)

Nota che anche se abbiamo modificato solo una riga, il risultato indica che due le righe sono state interessate perché in realtà DELETED la riga esistente quindi INSERTED la nuova riga per sostituirla.

Ulteriori informazioni sull'utilizzo di REPLACE può essere trovato nella documentazione ufficiale.

Utilizzo di INSERT ... ON DUPLICATE KEY UPDATE

Il metodo alternativo (e generalmente preferito) per INSERTING in righe che possono contenere UNIQUE duplicati o PRIMARY KEY valori consiste nell'usare INSERT ... ON DUPLICATE KEY UPDATE dichiarazione e clausola.

A differenza di REPLACE – un comando intrinsecamente distruttivo dovuto a DELETE comandi che esegue quando necessario, utilizzando INSERT ... ON DUPLICATE KEY UPDATE è non distruttivo , in quanto rilascerà sempre e solo INSERT o UPDATE dichiarazioni, ma mai DELETE .

Ad esempio, abbiamo deciso di sostituire il nostro id = 1 record di uova verdi e prosciutto e ripristina l'originale Alla ricerca del tempo perduto registrare invece. Possiamo quindi prendere il nostro INSERT originale istruzione e aggiungere il nuovo ON DUPLICATE KEY UPDATE clausola:

mysql> SET @id = 1,
    @title = 'In Search of Lost Time',
    @author = 'Marcel Proust',
    @year_published = 1913;
INSERT INTO books
    (id, title, author, year_published)
VALUES
    (@id, @title, @author, @year_published)
ON DUPLICATE KEY UPDATE
    title = @title,
    author = @author,
    year_published = @year_published;

Nota che stiamo usando il normale UPDATE sintassi (ma esclusa la table non necessaria nome e SET parola chiave), e assegnando solo il non-UNIQUE valori. Inoltre, sebbene non necessario per il ON DUPLICATE KEY UPDATE metodo per funzionare correttamente, abbiamo anche scelto di utilizzare user variables quindi non è necessario specificare i valori effettivi che vogliamo INSERT o UPDATE più di una volta.

Di conseguenza, il nostro id = 1 il record era correttamente UPDATED come previsto:

mysql> SELECT * FROM books LIMIT 1;
+----+------------------------+---------------+----------------+
| id | title                  | author        | year_published |
+----+------------------------+---------------+----------------+
|  1 | In Search of Lost Time | Marcel Proust |           1913 |
+----+------------------------+---------------+----------------+
1 row in set (0.00 sec)

Maggiori informazioni possono essere trovate nella documentazione ufficiale.