Der beste Weg, um zu testen, ob eine Zeile in einer MySQL-Tabelle vorhanden ist

Ich versuche herauszufinden, ob eine Zeile in einer Tabelle vorhanden ist. Mit MySQL ist es besser, eine Abfrage wie folgt durchzuführen:

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

und prüfen Sie, ob die Summe nicht Null ist oder ob es besser ist, eine Abfrage wie folgt durchzuführen:

SELECT * FROM table1 WHERE ... LIMIT 1

und prüfen, ob Zeilen zurückgegeben wurden?

In beiden Abfragen verwendet die WHERE-Klausel einen Index.

Sie könnten auch versuchen EXISTS:

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

und laut Dokumentation können Sie SELECTalles.

Traditionell beginnt eine EXISTS-Unterabfrage mit SELECT *, sie kann jedoch auch mit SELECT 5 oder SELECT column1 oder irgendetwas anderem beginnen. MySQL ignoriert die SELECT-Liste in einer solchen Unterabfrage, daher macht es keinen Unterschied.

Ich habe kürzlich einige Untersuchungen zu diesem Thema durchgeführt. Die Art und Weise der Implementierung muss unterschiedlich sein, wenn das Feld ein TEXT-Feld ist, ein nicht eindeutiges Feld.

Ich habe einige Tests mit einem TEXT-Feld durchgeführt. In Anbetracht der Tatsache, dass wir eine Tabelle mit 1M Einträgen haben. 37 Einträge sind gleich 'etwas':

• SELECT * FROM test WHERE texte LIKE '%something%' LIMIT 1mit mysql_num_rows() : 0.039061069488525s. (SCHNELLER)
• 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.

Aber jetzt, mit einem BIGINT PK-Feld, ist nur ein Eintrag gleich '321321':

• SELECT * FROM test2 WHERE id ='321321' LIMIT 1mit 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. (SCHNELLER)

Ein kurzes Beispiel für die Antwort von @ ChrisThompson

Beispiel:

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)

Verwenden eines Alias:

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

In meiner Forschung kann ich feststellen, dass das Ergebnis der folgenden Geschwindigkeit folgt.

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) 

Ich halte es für erwähnenswert, obwohl in den Kommentaren darauf hingewiesen wurde, dass in dieser Situation:

SELECT 1 FROM my_table WHERE *indexed_condition* LIMIT 1

Ist überlegen:

SELECT * FROM my_table WHERE *indexed_condition* LIMIT 1

Dies liegt daran, dass die erste Abfrage vom Index erfüllt werden kann, während die zweite eine Zeilensuche erfordert (es sei denn, möglicherweise befinden sich alle Spalten der Tabelle im verwendeten Index).

Durch Hinzufügen der LIMITKlausel kann die Engine gestoppt werden, nachdem eine Zeile gefunden wurde.

Die erste Abfrage sollte vergleichbar sein mit:

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

Was die gleichen Signale an den Motor sendet (1 / * macht hier keinen Unterschied), aber ich würde trotzdem die 1 schreiben, um die Gewohnheit bei der Verwendung zu verstärken EXISTS:

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

Es kann sinnvoll sein, die EXISTSUmhüllung hinzuzufügen , wenn Sie eine explizite Rückgabe benötigen, wenn keine Zeilen übereinstimmen.

Schlagen Sie vor, dass Sie nicht verwenden, Countda count immer zusätzliche Ladevorgänge für die Datenbankverwendung ausführt SELECT 1und 1 zurückgibt, wenn Ihr Datensatz genau dort ist, andernfalls null zurückgibt und Sie damit umgehen können.

Eine COUNT- Abfrage ist schneller, wenn auch möglicherweise nicht merklich, aber um das gewünschte Ergebnis zu erzielen, sollten beide ausreichend sein.

Manchmal ist es sehr praktisch, den Auto-Inkrement-Primärschlüssel ( id) der Zeile abzurufen, wenn er vorhanden ist und 0nicht.

So geht das in einer einzigen Abfrage:

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

Für Nicht-InnoDB-Tabellen können Sie auch die Informationsschematabellen verwenden:

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

Ich würde mitgehen COUNT(1). Es ist schneller alsCOUNT(*) weil COUNT(*)Tests, um festzustellen, ob mindestens eine Spalte in dieser Zeile! = NULL ist. Das brauchen Sie nicht, vor allem, weil Sie bereits eine Bedingung (die WHEREKlausel) haben. COUNT(1)testet stattdessen die Gültigkeit von 1, was immer gültig ist und viel weniger Zeit zum Testen benötigt.

Oder Sie können einen unformatierten SQL-Teil in Bedingungen einfügen, sodass ich 'Bedingungen' => Array habe ('Member.id NOT IN (SELECT Membership.member_id FROM Mitgliedschaften AS Mitgliedschaft)')

COUNT(*) sind in MySQL optimiert, sodass die vorherige Abfrage im Allgemeinen wahrscheinlich schneller ist.