Sådan INSERT Hvis række ikke eksisterer (UPSERT) i MySQL

• Ved brug af INSERT IGNORE
• Ved brug af REPLACE
• Ved brug af INSERT ... ON DUPLICATE KEY UPDATE

MySQL giver en række nyttige udsagn, når det er nødvendigt at INSERT rækker efter afgøre, om denne række faktisk er ny eller allerede eksisterer.

Nedenfor vil vi undersøge de tre forskellige metoder og forklare fordele og ulemper ved hver efter tur, så du har et solidt greb om, hvordan du konfigurerer dine egne udsagn, når du leverer nye eller potentielt eksisterende data til INSERTION .

Brug af INSERT IGNORE

Brug af INSERT IGNORE får effektivt MySQL til at ignorere udførelsesfejl under forsøg på at udføre INSERT udsagn. Dette betyder, at en INSERT IGNORE sætning, som indeholder en dubletværdi i en UNIQUE indeks eller PRIMARY KEY felt ikke producere en fejl, men vil i stedet blot ignorere den pågældende INSERT kommando helt. Det åbenlyse formål er at udføre et stort antal INSERT sætninger for en kombination af data, der både allerede findes i databasen, samt nye data, der kommer ind i systemet.

For eksempel vores books tabel kan allerede indeholde nogle få poster:

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)

Hvis vi har en stor batch af nye og eksisterende data at INSERT og en del af disse data indeholder en matchende værdi for id felt (som er en UNIQUE PRIMARY_KEY i tabellen), ved hjælp af en grundlæggende INSERT vil producere en forventet fejl:

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'

På den anden side, hvis vi bruger INSERT IGNORE , duplikeringsforsøget ignoreres, og der opstår ingen resulterende fejl:

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)

Brug af REPLACE

I tilfælde af at du faktisk ønsker at erstatte rækker hvor INSERT kommandoer ville producere fejl på grund af dublet UNIQUE eller PRIMARY KEY værdier som beskrevet ovenfor, er en mulighed at vælge REPLACE erklæring.

Når du udsteder en REPLACE sætning, er der to mulige udfald for hver udsendt kommando:

• Der blev ikke fundet nogen eksisterende datarække med matchende værdier og dermed en standard INSERT erklæring udføres.
• En matchende datarække er fundet, hvilket forårsager, at den eksisterende række bliver slettet med standarden DELETE sætning, derefter en normal INSERT udføres efterfølgende.

For eksempel kan vi bruge REPLACE for at udskifte vores eksisterende registrering af id = 1 af I Search of Lost Time af Marcel Proust med Grønne æg og skinke af 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)

Bemærk, at selvom vi kun har ændret én række, indikerer resultatet, at to rækker blev påvirket, fordi vi faktisk DELETED den eksisterende række og derefter INSERTED den nye række for at erstatte den.

Flere oplysninger om brug af REPLACE kan findes i den officielle dokumentation.

Brug af INSERT ... ON DUPLICATE KEY UPDATE

Den alternative (og generelt foretrukne) metode til INSERTING i rækker, der kan indeholde dublet UNIQUE eller PRIMARY KEY værdier er at bruge INSERT ... ON DUPLICATE KEY UPDATE erklæring og klausul.

I modsætning til REPLACE – en iboende destruktiv kommando på grund af DELETE kommandoer, den udfører, når det er nødvendigt – ved hjælp af INSERT ... ON DUPLICATE KEY UPDATE er ikke-destruktiv , idet den kun vil udstede INSERT eller UPDATE udsagn, men aldrig DELETE .

For eksempel har vi besluttet, at vi ønsker at erstatte vores id = 1 registrering af grønne æg og skinke og vend det tilbage til den originale In Search of Lost Time optage i stedet for. Vi kan derfor tage vores originale INSERT sætning og tilføj den nye ON DUPLICATE KEY UPDATE klausul:

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;

Bemærk, at vi bruger normal UPDATE syntaks (men med undtagelse af den unødvendige table navn og SET nøgleord), og kun tildeler non-UNIQUE værdier. Også selvom det er unødvendigt for ON DUPLICATE KEY UPDATE metode til at fungere korrekt, har vi også valgt at bruge user variables så vi behøver ikke at angive de faktiske værdier, vi vil INSERT eller UPDATE mere end én gang.

Som et resultat er vores id = 1 posten var korrekt UPDATED som forventet:

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)

Mere information kan findes i den officielle dokumentation.