Meilleure façon de tester si une ligne existe dans une table MySQL

J'essaie de savoir si une ligne existe dans une table. En utilisant MySQL, est-il préférable de faire une requête comme celle-ci:

SELECT COUNT(*) AS total FROM table1 WHERE ...

et vérifiez si le total est différent de zéro ou est-il préférable de faire une requête comme celle-ci:

SELECT * FROM table1 WHERE ... LIMIT 1

et vérifier si des lignes ont été retournées?

Dans les deux requêtes, la clause WHERE utilise un index.

Vous pouvez également essayer EXISTS:

SELECT EXISTS(SELECT * FROM table1 WHERE ...)

et selon la documentation , vous pouvez SELECTtout.

Traditionnellement, une sous-requête EXISTS commence par SELECT *, mais elle peut commencer par SELECT 5 ou SELECT column1 ou quoi que ce soit. MySQL ignore la liste SELECT dans une telle sous-requête, donc cela ne fait aucune différence.

J'ai fait quelques recherches sur ce sujet récemment. La façon de l'implémenter doit être différente si le champ est un champ TEXTE, un champ non unique.

J'ai fait quelques tests avec un champ TEXT. Compte tenu du fait que nous avons une table avec 1M d'entrées. 37 entrées sont égales à «quelque chose»:

• SELECT * FROM test WHERE texte LIKE '%something%' LIMIT 1avec mysql_num_rows() : 0,039061069488525s. (PLUS RAPIDE)
• SELECT count(*) as count FROM test WHERE text LIKE '%something% : 16.028197050095s.
• SELECT EXISTS(SELECT 1 FROM test WHERE text LIKE '%something%') : 0.87045907974243s.
• SELECT EXISTS(SELECT 1 FROM test WHERE text LIKE '%something%' LIMIT 1) : 0,044898986816406s.

Mais maintenant, avec un champ BIGINT PK, une seule entrée est égale à '321321':

• SELECT * FROM test2 WHERE id ='321321' LIMIT 1avec mysql_num_rows() : 0,0089840888977051s.
• SELECT count(*) as count FROM test2 WHERE id ='321321' : 0.00033879280090332s.
• SELECT EXISTS(SELECT 1 FROM test2 WHERE id ='321321') : 0,00023889541625977s.
• SELECT EXISTS(SELECT 1 FROM test2 WHERE id ='321321' LIMIT 1): 0.00020313262939453s. (PLUS RAPIDE)

Un bref exemple de la réponse de @ ChrisThompson

Exemple:

mysql> SELECT * FROM table_1;
+----+--------+
| id | col1   |
+----+--------+
|  1 | foo    |
|  2 | bar    |
|  3 | foobar |
+----+--------+
3 rows in set (0.00 sec)

mysql> SELECT EXISTS(SELECT 1 FROM table_1 WHERE id = 1);
+--------------------------------------------+
| EXISTS(SELECT 1 FROM table_1 WHERE id = 1) |
+--------------------------------------------+
|                                          1 |
+--------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXISTS(SELECT 1 FROM table_1 WHERE id = 9);
+--------------------------------------------+
| EXISTS(SELECT 1 FROM table_1 WHERE id = 9) |
+--------------------------------------------+
|                                          0 |
+--------------------------------------------+
1 row in set (0.00 sec)

Utilisation d'un alias:

mysql> SELECT EXISTS(SELECT 1 FROM table_1 WHERE id = 1) AS mycheck;
+---------+
| mycheck |
+---------+
|       1 |
+---------+
1 row in set (0.00 sec)

Dans mes recherches, je peux trouver le résultat à la vitesse suivante.

select * from table where condition=value
(1 total, Query took 0.0052 sec)

select exists(select * from table where condition=value)
(1 total, Query took 0.0008 sec)

select count(*) from table where condition=value limit 1) 
(1 total, Query took 0.0007 sec)

select exists(select * from table where condition=value limit 1)
(1 total, Query took 0.0006 sec) 

Je pense qu'il convient de souligner, bien que cela ait été évoqué dans les commentaires, que dans cette situation:

SELECT 1 FROM my_table WHERE *indexed_condition* LIMIT 1

Est supérieur à:

SELECT * FROM my_table WHERE *indexed_condition* LIMIT 1

En effet, la première requête peut être satisfaite par l'index, tandis que la seconde nécessite une recherche de ligne (sauf si toutes les colonnes de la table se trouvent dans l'index utilisé).

L'ajout de la LIMITclause permet au moteur de s'arrêter après avoir trouvé une ligne.

La première requête doit être comparable à:

SELECT EXISTS(SELECT * FROM my_table WHERE *indexed_condition*)

Ce qui envoie les mêmes signaux au moteur (1 / * ne fait aucune différence ici), mais j'écrirais toujours le 1 pour renforcer l'habitude lors de l'utilisation EXISTS:

SELECT EXISTS(SELECT 1 FROM my_table WHERE *indexed_condition*)

Il peut être judicieux d'ajouter l' EXISTShabillage si vous avez besoin d'un retour explicite lorsqu'aucune ligne ne correspond.

Nous vous suggérons de ne pas l'utiliser, Countcar le nombre crée toujours des charges supplémentaires pour l'utilisation de la base de données SELECT 1et renvoie 1 si votre enregistrement est là, sinon, il renvoie null et vous pouvez le gérer.

Une requête COUNT est plus rapide, bien que peut-être pas sensiblement, mais en ce qui concerne l'obtention du résultat souhaité, les deux devraient être suffisants.

Parfois, il est très pratique d'obtenir la clé primaire d'incrémentation automatique ( id) de la ligne si elle existe et 0si elle n'existe pas.

Voici comment cela peut être fait en une seule requête:

SELECT IFNULL(`id`, COUNT(*)) FROM WHERE ...

Pour les tables non InnoDB, vous pouvez également utiliser les tables de schéma d'information:

http://dev.mysql.com/doc/refman/5.1/en/tables-table.html

J'irais avec COUNT(1). C'est plus rapide que COUNT(*)parce que des COUNT(*)tests pour voir si au moins une colonne de cette ligne est! = NULL. Vous n'en avez pas besoin, surtout parce que vous avez déjà une condition en place (la WHEREclause). COUNT(1)teste plutôt la validité de 1, qui est toujours valide et prend beaucoup moins de temps à tester.

Ou vous pouvez insérer une partie SQL brute dans les conditions pour que j'aie 'conditions' => tableau ('Member.id NOT IN (SELECT Membership.member_id FROM memberships AS Membership)'))

COUNT(*) sont optimisés dans MySQL, donc l'ancienne requête est susceptible d'être plus rapide, d'une manière générale.