Comment «insérer s'il n'existe pas» dans MySQL?

J'ai commencé par googler et j'ai trouvé cet article qui parle des tables mutex.

J'ai une table avec environ 14 millions d'enregistrements. Si je veux ajouter plus de données dans le même format, existe-t-il un moyen de s'assurer que l'enregistrement que je veux insérer n'existe pas déjà sans utiliser une paire de requêtes (c'est-à-dire, une requête à vérifier et une à insérer est l'ensemble de résultats est vide)?

Est-ce qu'une uniquecontrainte sur un champ garantit l' insertéchec s'il est déjà là?

Il semble qu'avec une simple contrainte, lorsque j'émets l'insert via php, le script coasse.

utilisation INSERT IGNORE INTO table

voir http://bogdan.org.ua/2007/10/18/mysql-insert-if-not-exists-syntax.html

il y a aussi la INSERT … ON DUPLICATE KEY UPDATEsyntaxe, vous pouvez trouver des explications sur dev.mysql.com

Publier sur bogdan.org.ua selon le webcache de Google :

18 octobre 2007

Pour commencer: depuis la dernière version de MySQL, la syntaxe présentée dans le titre n'est pas possible. Mais il existe plusieurs façons très simples d'accomplir ce qui est attendu en utilisant les fonctionnalités existantes.

Il existe 3 solutions possibles: utiliser INSERT IGNORE, REPLACE ou INSERT… ON DUPLICATE KEY UPDATE.

Imaginez que nous ayons une table:

CREATE TABLE `transcripts` (
`ensembl_transcript_id` varchar(20) NOT NULL,
`transcript_chrom_start` int(10) unsigned NOT NULL,
`transcript_chrom_end` int(10) unsigned NOT NULL,
PRIMARY KEY (`ensembl_transcript_id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Imaginez maintenant que nous ayons un pipeline automatique qui importe les métadonnées des transcriptions à partir d'Ensembl et que, pour diverses raisons, le pipeline peut être interrompu à n'importe quelle étape de l'exécution. Ainsi, nous devons garantir deux choses:

1. les exécutions répétées du pipeline ne détruiront pas notre base de données

2. les exécutions répétées ne mourront pas en raison d'erreurs de «clé primaire en double».

Méthode 1: utiliser REPLACE

C'est très simple:

REPLACE INTO `transcripts`
SET `ensembl_transcript_id` = 'ENSORGT00000000001',
`transcript_chrom_start` = 12345,
`transcript_chrom_end` = 12678;

Si l'enregistrement existe, il sera écrasé; s'il n'existe pas encore, il sera créé. Cependant, l'utilisation de cette méthode n'est pas efficace dans notre cas: nous n'avons pas besoin d'écraser les enregistrements existants, c'est bien de les ignorer.

Méthode 2: utiliser INSERT IGNORE Aussi très simple:

INSERT IGNORE INTO `transcripts`
SET `ensembl_transcript_id` = 'ENSORGT00000000001',
`transcript_chrom_start` = 12345,
`transcript_chrom_end` = 12678;

Ici, si 'ensembl_transcript_id' est déjà présent dans la base de données, il sera ignoré en silence (ignoré). (Pour être plus précis, voici une citation du manuel de référence MySQL: «Si vous utilisez le mot clé IGNORE, les erreurs qui se produisent lors de l'exécution de l'instruction INSERT sont traitées à la place comme des avertissements. Par exemple, sans IGNORE, une ligne qui duplique un index UNIQUE existant ou la valeur PRIMARY KEY dans le tableau provoque une erreur de clé en double et l'instruction est abandonnée. ”.) Si l'enregistrement n'existe pas encore, il sera créé.

Cette deuxième méthode présente plusieurs faiblesses potentielles, notamment la non interruption de la requête en cas de problème (voir le manuel). Il doit donc être utilisé s'il a été testé auparavant sans le mot clé IGNORE.

Méthode 3: en utilisant INSERT… ON DUPLICATE KEY UPDATE:

La troisième option consiste à utiliser la INSERT … ON DUPLICATE KEY UPDATE syntaxe, et dans la partie UPDATE, rien ne fait une opération dénuée de sens (vide), comme calculer 0 + 0 (Geoffray suggère de faire l'affectation id = id pour que le moteur d'optimisation MySQL ignore cette opération). L'avantage de cette méthode est qu'elle ignore uniquement les événements de clé en double et abandonne toujours d'autres erreurs.

Enfin, ce billet a été inspiré par Xaprb. Je conseillerais également de consulter son autre article sur l'écriture de requêtes SQL flexibles.

Solution:

INSERT INTO `table` (`value1`, `value2`) 
SELECT 'stuff for value1', 'stuff for value2' FROM DUAL 
WHERE NOT EXISTS (SELECT * FROM `table` 
      WHERE `value1`='stuff for value1' AND `value2`='stuff for value2' LIMIT 1) 

Explication:

La requête la plus profonde

SELECT * FROM `table` 
      WHERE `value1`='stuff for value1' AND `value2`='stuff for value2' LIMIT 1

utilisé comme WHERE NOT EXISTS-condition détecte s'il existe déjà une ligne avec les données à insérer. Une fois qu'une ligne de ce type a été trouvée, la requête peut s'arrêter, d'où LIMIT 1(la micro-optimisation peut être omise).

La requête intermédiaire

SELECT 'stuff for value1', 'stuff for value2' FROM DUAL

représente les valeurs à insérer. DUALfait référence à une table spéciale à une ligne et à une colonne présente par défaut dans toutes les bases de données Oracle (voir https://en.wikipedia.org/wiki/DUAL_table ). Sur une version 5.7.26 de MySQL-Server, j'ai reçu une requête valide lors de l'omission FROM DUAL, mais les versions plus anciennes (comme 5.5.60) semblent exiger les FROMinformations. L'utilisation de WHERE NOT EXISTSla requête intermédiaire renvoie un jeu de résultats vide si la requête la plus interne a trouvé des données correspondantes.

La requête externe

INSERT INTO `table` (`value1`, `value2`) 

insère les données, le cas échéant, est renvoyée par la requête intermédiaire.

sur la mise à jour de clé en double , ou l' insertion d'ignorer peut être une solution viable avec MySQL.

Exemple de mise à jour de mise à jour de clé en double basée sur mysql.com

INSERT INTO table (a,b,c) VALUES (1,2,3)
  ON DUPLICATE KEY UPDATE c=c+1;

UPDATE table SET c=c+1 WHERE a=1;

Exemple d' insertion ignorer basé sur mysql.com

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
    [INTO] tbl_name [(col_name,...)]
    {VALUES | VALUE} ({expr | DEFAULT},...),(...),...
    [ ON DUPLICATE KEY UPDATE
      col_name=expr
        [, col_name=expr] ... ]

Ou:

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
    [INTO] tbl_name
    SET col_name={expr | DEFAULT}, ...
    [ ON DUPLICATE KEY UPDATE
      col_name=expr
        [, col_name=expr] ... ]

Ou:

INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
    [INTO] tbl_name [(col_name,...)]
    SELECT ...
    [ ON DUPLICATE KEY UPDATE
      col_name=expr
        [, col_name=expr] ... ]

Toute contrainte simple devrait faire l'affaire, si une exception est acceptable. Exemples :

• clé primaire sinon substitut
• contrainte unique sur une colonne
• contrainte unique multi-colonnes

Désolé, cela semble d'une simplicité trompeuse. Je sais que ça fait mal face au lien que vous partagez avec nous. ;-(

Mais je donne toujours cette réponse, car elle semble répondre à votre besoin. (Sinon, cela peut déclencher la mise à jour de vos besoins, ce qui serait également "une bonne chose" (TM)).

Modifié : si une insertion rompait la contrainte unique de la base de données, une exception est levée au niveau de la base de données, relayée par le pilote. Cela arrêtera certainement votre script, avec un échec. Il doit être possible en PHP de traiter ce cas ...

Voici une fonction PHP qui insérera une ligne uniquement si toutes les valeurs de colonnes spécifiées n'existent pas déjà dans la table.

• Si l'une des colonnes diffère, la ligne sera ajoutée.

• Si le tableau est vide, la ligne sera ajoutée.

• S'il existe une ligne où toutes les colonnes spécifiées ont les valeurs spécifiées, la ligne ne sera pas ajoutée.

  function insert_unique($table, $vars)
  {
    if (count($vars)) {
      $table = mysql_real_escape_string($table);
      $vars = array_map('mysql_real_escape_string', $vars);
  
      $req = "INSERT INTO `$table` (`". join('`, `', array_keys($vars)) ."`) ";
      $req .= "SELECT '". join("', '", $vars) ."' FROM DUAL ";
      $req .= "WHERE NOT EXISTS (SELECT 1 FROM `$table` WHERE ";
  
      foreach ($vars AS $col => $val)
        $req .= "`$col`='$val' AND ";
  
      $req = substr($req, 0, -5) . ") LIMIT 1";
  
      $res = mysql_query($req) OR die();
      return mysql_insert_id();
    }
  
    return False;
  }

Exemple d'utilisation:

<?php
insert_unique('mytable', array(
  'mycolumn1' => 'myvalue1',
  'mycolumn2' => 'myvalue2',
  'mycolumn3' => 'myvalue3'
  )
);
?>

REPLACE INTO `transcripts`
SET `ensembl_transcript_id` = 'ENSORGT00000000001',
`transcript_chrom_start` = 12345,
`transcript_chrom_end` = 12678;

Si l'enregistrement existe, il sera écrasé; s'il n'existe pas encore, il sera créé.

Essayez ce qui suit:

IF (SELECT COUNT(*) FROM beta WHERE name = 'John' > 0)
  UPDATE alfa SET c1=(SELECT id FROM beta WHERE name = 'John')
ELSE
BEGIN
  INSERT INTO beta (name) VALUES ('John')
  INSERT INTO alfa (c1) VALUES (LAST_INSERT_ID())
END

Il existe plusieurs réponses qui expliquent comment résoudre ce problème si vous disposez d'un UNIQUEindex que vous pouvez vérifier avec ON DUPLICATE KEYou INSERT IGNORE. Ce n'est pas toujours le cas, et comme UNIQUEpour une contrainte de longueur (1000 octets), vous ne pourrez peut-être pas changer cela. Par exemple, j'ai dû travailler avec des métadonnées dans WordPress ( wp_postmeta).

Je l'ai finalement résolu avec deux requêtes:

UPDATE wp_postmeta SET meta_value = ? WHERE meta_key = ? AND post_id = ?;
INSERT INTO wp_postmeta (post_id, meta_key, meta_value) SELECT DISTINCT ?, ?, ? FROM wp_postmeta WHERE NOT EXISTS(SELECT * FROM wp_postmeta WHERE meta_key = ? AND post_id = ?);

La requête 1 est une UPDATErequête régulière sans effet lorsque l'ensemble de données en question n'est pas là. La requête 2 est un INSERTqui dépend de a NOT EXISTS, c'est-à- INSERTdire que n'est exécuté que lorsque l'ensemble de données n'existe pas.

Il convient de noter que INSERT IGNORE incrémentera toujours la clé primaire, que l'instruction soit un succès ou non, tout comme le ferait un INSERT normal.

Cela entraînera des lacunes dans vos clés primaires qui pourraient rendre un programmeur mentalement instable. Ou si votre application est mal conçue et dépend de clés primaires incrémentielles parfaites, cela pourrait devenir un casse-tête.

Examinez innodb_autoinc_lock_mode = 0(paramètre du serveur et est accompagné d'un léger hit de performance), ou utilisez d'abord SELECT pour vous assurer que votre requête n'échouera pas (qui est également fournie avec un hit de performance et du code supplémentaire).

Mettre à jour ou insérer sans clé primaire connue

Si vous avez déjà une clé unique ou primaire, les autres réponses avec soit INSERT INTO ... ON DUPLICATE KEY UPDATE ...ou REPLACE INTO ...devraient fonctionner correctement (notez que remplacer en supprime s'il existe puis insère - donc ne met pas à jour partiellement les valeurs existantes).

Mais si vous avez les valeurs pour some_column_idet some_typedont la combinaison est connue pour être unique. Et vous souhaitez mettre à jour some_values'il existe, ou insérer s'il n'existe pas. Et vous voulez le faire en une seule requête (pour éviter d'utiliser une transaction). Cela pourrait être une solution:

INSERT INTO my_table (id, some_column_id, some_type, some_value)
SELECT t.id, t.some_column_id, t.some_type, t.some_value
FROM (
    SELECT id, some_column_id, some_type, some_value
    FROM my_table
    WHERE some_column_id = ? AND some_type = ?
    UNION ALL
    SELECT s.id, s.some_column_id, s.some_type, s.some_value
    FROM (SELECT NULL AS id, ? AS some_column_id, ? AS some_type, ? AS some_value) AS s
) AS t
LIMIT 1
ON DUPLICATE KEY UPDATE
some_value = ?

Fondamentalement, la requête s'exécute de cette façon (moins compliquée qu'elle n'y paraît):

• Sélectionnez une ligne existante via la WHEREcorrespondance de clause.
• Union qui résulte avec une nouvelle ligne potentielle (table s), où les valeurs de colonne sont explicitement données (s.id est NULL, donc il va générer un nouvel identifiant d'incrémentation automatique).
• Si une ligne existante est trouvée, la nouvelle ligne potentielle de la table sest ignorée (en raison de LIMIT 1 sur la table t), et elle déclenchera toujours une ON DUPLICATE KEYqui sera UPDATEla some_valuecolonne.
• Si une ligne existante n'est pas trouvée, la nouvelle ligne potentielle est insérée (comme indiqué par le tableau s).

Remarque: Chaque table dans une base de données relationnelle doit avoir au moins une incrémentation automatique principale id colonne d' . Si vous ne l'avez pas, ajoutez-le, même lorsque vous n'en avez pas besoin à première vue. Il est absolument nécessaire pour ce "truc".