Najlepszy sposób na sprawdzenie, czy wiersz istnieje w tabeli MySQL

Próbuję dowiedzieć się, czy wiersz istnieje w tabeli. Korzystając z MySQL, lepiej wykonać takie zapytanie:

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

i sprawdź, czy suma jest różna od zera, czy lepiej jest wykonać takie zapytanie:

SELECT * FROM table1 WHERE ... LIMIT 1

i sprawdź, czy zostały zwrócone jakieś wiersze?

W obu zapytaniach klauzula WHERE używa indeksu.

Możesz także spróbować EXISTS:

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

i zgodnie z dokumentacją możesz SELECTwszystko.

Tradycyjnie podzapytanie EXISTS zaczyna się od SELECT *, ale może zaczynać się od SELECT 5 lub SELECT column1 lub cokolwiek innego. MySQL ignoruje listę SELECT w takim podzapytaniu, więc nie ma znaczenia.

Ostatnio przeprowadziłem kilka badań na ten temat. Sposób implementacji musi być inny, jeśli pole jest polem TEXT, polem nie unikalnym.

Zrobiłem kilka testów z polem TEXT. Biorąc pod uwagę fakt, że mamy tabelę z wpisami 1M. 37 wpisów jest równych „coś”:

• SELECT * FROM test WHERE texte LIKE '%something%' LIMIT 1z mysql_num_rows() : 0,039061069488525s. (SZYBCIEJ)
• 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.

Ale teraz, z polem BIGINT PK, tylko jeden wpis jest równy „321321”:

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

Krótki przykład odpowiedzi @ ChrisThompson

Przykład:

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)

Korzystanie z aliasu:

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

W moich badaniach mogę znaleźć wynik postępujący z prędkością.

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) 

Wydaje mi się, że warto zwrócić uwagę, choć poruszono to w komentarzach, że w tej sytuacji:

SELECT 1 FROM my_table WHERE *indexed_condition* LIMIT 1

Jest lepszy od:

SELECT * FROM my_table WHERE *indexed_condition* LIMIT 1

Wynika to z faktu, że pierwsze zapytanie może być spełnione przez indeks, podczas gdy drugie wymaga wyszukiwania wiersza w górę (chyba że wszystkie kolumny tabeli znajdują się w użytym indeksie).

Dodanie LIMITklauzuli pozwala zatrzymać silnik po znalezieniu dowolnego wiersza.

Pierwsze zapytanie powinno być porównywalne z:

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

Który wysyła te same sygnały do ​​silnika (1 / * nie ma tutaj znaczenia), ale nadal zapisałbym 1, aby wzmocnić nawyk podczas używania EXISTS:

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

Sensowne może być dodanie EXISTSopakowania, jeśli wymagany jest wyraźny zwrot, gdy żadne wiersze nie pasują.

Sugeruj, abyś nie używał, Countponieważ count zawsze powoduje dodatkowe obciążenia dla użycia bazy danych SELECT 1i zwraca 1, jeśli twój rekord w tym miejscu zwraca wartość null i możesz to obsłużyć.

COUNT zapytania jest szybsza, choć może nie zauważalnie, ale jeśli chodzi o uzyskanie pożądanego rezultatu, oba powinny być wystarczające.

Czasami bardzo przydatne jest uzyskanie klucza podstawowego automatycznego przyrostu ( id) wiersza, jeśli istnieje i0 jeśli nie.

Oto, jak można to zrobić za pomocą jednego zapytania:

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

W przypadku tabel innych niż InnoDB można również użyć tabel schematów informacyjnych:

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

Poszedłbym z COUNT(1). Jest szybszy niż COUNT(*)ponieważ COUNT(*)testy sprawdzają, czy przynajmniej jedna kolumna w tym wierszu ma wartość! = NULL. Nie potrzebujesz tego, zwłaszcza że masz już warunek ( WHEREklauzula). COUNT(1)zamiast tego testuje ważność 1, która jest zawsze ważna i zajmuje dużo mniej czasu na testowanie.

Lub możesz wstawić surową część sql do warunków, więc mam „warunki” => tablica („Member.id NOT IN (SELECT Membership.member_id Z członkostwa AS Członkostwo)”)

COUNT(*) są zoptymalizowane w MySQL, więc poprzednie zapytanie prawdopodobnie będzie szybsze.