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

J'essaie de savoir si une ligne existe dans une table. L'utilisation de MySQL, est-il préférable de faire une requête comme ceci:

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

et vérifier pour voir si le total est non-nul, ou est-il préférable de faire une requête comme ceci:

SELECT * FROM table1 WHERE ... LIMIT 1

et vérifier pour voir si toutes les lignes ont été retournés?

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

InformationsquelleAutor Bernard Chen | 2009-11-04

423

Vous pouvez également essayer d'utiliser
```
SELECT EXISTS(SELECT * FROM table1 WHERE ...)
```
par la documentation

Par un commentaire ci-dessous:
```
SELECT EXISTS(SELECT 1 FROM table1 WHERE ...)
```
- Test avec ...EXISTS( SELECT 1/0 FROM someothertable). Pour SQL Server & Oracle - il ne fait aucune différence à utiliser *, 1 ou NULLE, car il EXISTE seulement des tests pour un booléen basé sur 1+ d'OÙ les critères d'appariement.
- Les gars, il est dit dans la documentation liée à cette réponse, 2e paragraphe, "Traditionnellement, une EXISTE une sous-requête commence par SELECT *, mais il pourrait commencer avec une sélection de 5 ou SELECT column1 ou quoi que ce soit. MySQL ignore la liste de sélection dans un sous-requête, de sorte qu'il ne fait aucune différence."
- ce qui se passe lorsque l'instruction est exécutée? Je veux dire qu'est le jeu de résultats contient-il?
- il contient si un 0 (n'existe pas) ou 1 (existe).
- La déclaration de retour de type bool ou unsigned char type? Je suis en train d'élaborer à l'aide de l'API C et j'ai besoin de savoir cela. Merci.
- selon la documentation, il renvoie un type bool.
- Je pense que votre requête est superflu, je l'ai testé, et cette requête SELECT 1 FROM table1 WHERE col = $var LIMIT 1 est plus rapide que votre requête. Alors, quel est l'avantage de votre requête?
- fait un excellent moment, c'est facile à oublier. L'absence d'une option ci-dessus est SELECT 1 FROM test WHERE ... LIMIT 1, sans SELECT EXISTS autour d'elle. Peut-être un poil plus rapide de cette façon.
InformationsquelleAutor Chris Thompson
164

J'ai fait quelques recherches à ce sujet récemment. La façon de mettre en œuvre elle doit être différente si le champ est un champ de TEXTE, un champ unique.

J'ai fait quelques tests avec un champ de TEXTE. 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 1 avec
  mysql_num_rows() : 0.039061069488525 s. (Plus RAPIDE)
- SELECT count(*) as count FROM test WHERE text LIKE '%something% :
  16.028197050095 s.
- SELECT EXISTS(SELECT 1 FROM test WHERE text LIKE '%something%') :
  0.87045907974243 s.
- SELECT EXISTS(SELECT 1 FROM test WHERE text LIKE '%something%' LIMIT 1) : 0.044898986816406 s.
Mais maintenant, avec un BIGINT PK champ, une seule entrée est égal à '321321' :
- SELECT * FROM test2 WHERE id ='321321' LIMIT 1 avec
  mysql_num_rows() : 0.0089840888977051 s.
- SELECT count(*) as count FROM test2 WHERE id ='321321' : 0.00033879280090332 s.
- SELECT EXISTS(SELECT 1 FROM test2 WHERE id ='321321') : 0.00023889541625977 s.
- SELECT EXISTS(SELECT 1 FROM test2 WHERE id ='321321' LIMIT 1) : 0.00020313262939453 s. (Plus RAPIDE)
- Merci pour la réponse supplémentaire. Avez-vous trouver la différence de temps entre les deux meilleurs options pour un champ de TEXTE pour être assez cohérente? La différence ne semble pas grande, et à l'aide de SELECT EXISTS(SELECT 1 ... la LIMITE 1) semble être très bon dans les deux cas.
- Vous avez raison, la différence n'est pas si important en ce qui concerne les autres résultats concernant le champ de texte. Néanmoins, peut-être que la requête serait mieux à l'aide d' SELECT 1 FROM test WHERE texte LIKE '%something%' LIMIT 1
- J'ai essayé sur mysql et dans le cas où vous utilisez select 1 ... limit 1, il est inutile de les entourer avec sélectionnez existe
- il ya une différence. SÉLECTIONNEZ EXISTE ... donne le vrai et le faux de la valeur (1 ou 0), tout en SÉLECTIONNER 1 ... donne 1 ou vide. Il y a différence entre la valeur faux et vide de sens, selon votre situation.
- fait un excellent moment, c'est facile à oublier. Manquant dans le calendrier des tests ci-dessus est SELECT 1 FROM test WHERE ..., sans SELECT EXISTS autour d'elle. Sans doute un poil plus rapide de cette façon.
- Je crois SELECT *... devient plus lente à mesure que vous ajoutez plus de colonnes. Je serais curieux de voir comment tout cela se compare à SÉLECTIONNER id...
- Ce n'est presque certainement parce que le PK sélectionner peut être satisfait par l'index pour SÉLECTIONNER 1, mais pas pour le SÉLECTIONNER * qui nécessite une ligne de recherche. Le TEXTE sélectionnez les besoins d'une recherche de ligne de toute façon, à cause de la condition. SELECT 1 FROM ... WHERE ... LIMIT 1 vous donnera le meilleur des deux mondes.. ajouter le EXISTE d'emballage si vous avez besoin d'un retour boolean pour pas de lignes correspondantes.
InformationsquelleAutor Laurent W.

Un court exemple de @ChrisThompson la réponse de

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)

À l'aide 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)

InformationsquelleAutor jaltek

Dans mes recherches, je trouve le résultat à obtenir sur la suite de vitesse.

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)

InformationsquelleAutor shihab mm

5

Je pense qu'il est intéressant de souligner, bien qu'il ait été abordé 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
```
C'est parce que la première requête peut être satisfaite par l'indice, alors que la seconde nécessite une ligne rechercher (sauf peut-être toutes les colonnes de la table sont dans l'index utilisé).

L'ajout de la LIMIT clause permet au moteur de s'arrêter après de trouver n'importe quelle ligne.

La première requête doit être comparable:
```
SELECT EXISTS(SELECT * FROM my_table WHERE *indexed_condition*)
```
Qui envoie les signaux vers le moteur (1/* ne fait pas de différence ici), mais je serais encore écrire l'1 à renforcer l'habitude lors de l'utilisation de EXISTS:
```
SELECT EXISTS(SELECT 1 FROM my_table WHERE *indexed_condition*)
```
Il peut être judicieux d'ajouter le EXISTS d'emballage si vous avez besoin d'un retour explicite lorsqu'aucune correspondance de lignes.

InformationsquelleAutor Arth
4

Vous suggérons de ne pas utiliser Count parce que le comte a toujours fait des charges supplémentaires pour la db utiliser SELECT 1 et il retourne 1 si votre dossier là sinon elle renvoie null et que vous pouvez le manipuler.

InformationsquelleAutor Fatih Karatana
2

Parfois il est assez pratique pour obtenir l'incrément automatique de la clé primaire (id) de la ligne si elle existe et 0 si elle ne le fait pas.

Voici comment cela peut être fait en une seule requête:
```
SELECT IFNULL(`id`, COUNT(*)) FROM WHERE ...
```
- Pourquoi ne pas simplement utiliser IFNULL(id, 0) ici au lieu de la COUNT(*)?
InformationsquelleAutor Zaxter
0

J'irais avec COUNT(1). Il est plus rapide que COUNT(*) parce que COUNT(*) des tests pour voir si au moins une colonne de la rangée est != La valeur NULL. Vous n'avez pas besoin de cela, surtout parce que vous disposez déjà d'une condition en place (le WHERE clause). COUNT(1) au lieu teste la validité de 1, qui est toujours valable et prend beaucoup moins de temps pour tester.
- -1 C'est faux. COUNT(*) ne pas regarder les valeurs de la colonne: il suffit de compter le nombre de lignes. Voir ma réponse ici: stackoverflow.com/questions/2876909/...
- COUNT() est beaucoup plus lente que celle qui EXISTE comme il en EXISTE peut revenir quand il trouve d'abord une ligne
InformationsquelleAutor Felix
0

Un Le COMTE requête est plus rapide, bien que peut-être pas sensiblement, mais jusqu'à obtenir le résultat souhaité, à la fois devrait suffire.
- Ce n'est cependant DB spécifiques. Le COUNT(*) est connu pour être lent dans PostgreSQL. Mieux serait de sélectionner les PK colonne et voir si elle retourne toutes les lignes.
- COUNT(*) est lent en InnoDB si
InformationsquelleAutor jaywon
-1

Pour les non-tables InnoDB vous pouvez également utiliser les informations de schéma de tables:

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

InformationsquelleAutor davek
-1

Ou vous pouvez insérer raw sql partie à des conditions
j'ai donc
'conditions'=>array('Membre.id not IN (SELECT Membres.member_id D'abonnements QUE l'Adhésion)')

InformationsquelleAutor user4193303
-2

COUNT(*) sont optimisés en MySQL, de sorte que l'ancienne requête est susceptible d'être plus rapide, d'une manière générale.
- Faites-vous référence à l'optimisation de la MyISAM a pour sélectionner le nombre de pièces pour l'ensemble de la table? Je ne pense pas que l'ont aidé s'il y avait une condition where.
InformationsquelleAutor Arthur Reutenauer

Vous devez vous connecter pour publier un commentaire.