Cómo INSERTAR si la fila no existe (UPSERT) en MySQL

• Usando INSERT IGNORE
• Usando REPLACE
• Utilizando INSERT ... ON DUPLICATE KEY UPDATE

MySQL proporciona una serie de declaraciones útiles cuando es necesario INSERT filas después determinar si esa fila es, de hecho, nueva o ya existe.

A continuación, examinaremos los tres métodos diferentes y explicaremos los pros y los contras de cada uno para que tenga una idea clara de cómo configurar sus propias declaraciones al proporcionar datos nuevos o potencialmente existentes para INSERTION .

Usando INSERT IGNORE

Usando INSERT IGNORE efectivamente hace que MySQL ignore errores de ejecución al intentar realizar INSERT declaraciones. Esto significa que un INSERT IGNORE declaración que contiene un valor duplicado en un UNIQUE índice o PRIMARY KEY campo no producirá un error, sino que simplemente ignorará ese INSERT en particular manda por completo. El propósito obvio es ejecutar una gran cantidad de INSERT declaraciones para una combinación de datos que ya existen en la base de datos, así como nuevos datos que ingresan al sistema.

Por ejemplo, nuestros books la tabla podría contener ya algunos registros:

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)

Si tenemos un gran lote de datos nuevos y existentes para INSERT y parte de esos datos contiene un valor coincidente para el id (que es un campo UNIQUE PRIMARY_KEY en la tabla), usando un INSERT básico producirá un error esperado:

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'

Por otro lado, si usamos INSERT IGNORE , se ignora el intento de duplicación y no se producen errores resultantes:

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)

Usando REPLACE

En caso de que desee reemplazar filas donde INSERT los comandos producirían errores debido a la duplicación de UNIQUE o PRIMARY KEY valores como se describe arriba, una opción es optar por REPLACE declaración.

Al emitir un REPLACE declaración, hay dos resultados posibles para cada comando emitido:

• No se encuentra ninguna fila de datos existente con valores coincidentes y, por lo tanto, un INSERT estándar se realiza la declaración.
• Una fila de datos coincidentes es encontrado, lo que hace que esa fila existente se elimine con el estándar DELETE declaración, luego un INSERT normal se realiza después.

Por ejemplo, podemos usar REPLACE para intercambiar nuestro registro existente de id = 1 de En busca del tiempo perdido de Marcel Proust con Huevos verdes con jamón por 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)

Observe que aunque solo modificamos una fila, el resultado indica que dos las filas se vieron afectadas porque en realidad DELETED la fila existente entonces INSERTED la nueva fila para reemplazarla.

Más información sobre el uso de REPLACE se puede encontrar en la documentación oficial.

Usando INSERT ... ON DUPLICATE KEY UPDATE

El método alternativo (y generalmente preferido) para INSERTING en filas que pueden contener UNIQUE duplicados o PRIMARY KEY valores es usar INSERT ... ON DUPLICATE KEY UPDATE declaración y cláusula.

A diferencia de REPLACE – un comando inherentemente destructivo debido al DELETE comandos que ejecuta cuando es necesario, usando INSERT ... ON DUPLICATE KEY UPDATE es no destructivo , en el sentido de que solo emitirá INSERT o UPDATE declaraciones, pero nunca DELETE .

Por ejemplo, hemos decidido que deseamos reemplazar nuestro id = 1 récord de Huevos Verdes con Jamón y revertirlo al original En busca del tiempo perdido grabar en su lugar. Por lo tanto, podemos tomar nuestro INSERT original declaración y agregue el nuevo ON DUPLICATE KEY UPDATE cláusula:

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;

Tenga en cuenta que estamos usando UPDATE normal sintaxis (pero excluyendo la innecesaria table nombre y SET palabra clave), y solo asignando el non-UNIQUE valores. Además, aunque innecesario para ON DUPLICATE KEY UPDATE método funcione correctamente, también hemos optado por utilizar user variables por lo que no necesitamos especificar los valores reales que queremos INSERT o UPDATE más de una vez.

Como resultado, nuestro id = 1 el registro fue correctamente UPDATED como se esperaba:

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)

Se puede encontrar más información en la documentación oficial.