La mejor manera de probar si existe una fila en una tabla MySQL

Estoy tratando de averiguar si existe una fila en una tabla. Usando MySQL, ¿es mejor hacer una consulta como esta?

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

y verifique si el total no es cero o es mejor hacer una consulta como esta:

SELECT * FROM table1 WHERE ... LIMIT 1

y verifica si alguna fila fue devuelta?

En ambas consultas, la cláusula WHERE usa un índice.

También puedes probar EXISTS:

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

y según la documentación , puedes SELECTcualquier cosa.

Tradicionalmente, una subconsulta EXISTA comienza con SELECT *, pero podría comenzar con SELECT 5 o SELECT column1 o cualquier cosa. MySQL ignora la lista SELECT en dicha subconsulta, por lo que no hay diferencia.

He realizado algunas investigaciones sobre este tema recientemente. La forma de implementarlo debe ser diferente si el campo es un campo TEXTO, un campo no único.

He realizado algunas pruebas con un campo TEXTO. Considerando el hecho de que tenemos una tabla con 1M de entradas. 37 entradas son iguales a 'algo':

• SELECT * FROM test WHERE texte LIKE '%something%' LIMIT 1con mysql_num_rows() : 0.039061069488525s. (MÁS RÁPIDO)
• 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.

Pero ahora, con un campo BIGINT PK, solo una entrada es igual a '321321':

• SELECT * FROM test2 WHERE id ='321321' LIMIT 1con 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. (MÁS RÁPIDO)

Un breve ejemplo de la respuesta de @ ChrisThompson

Ejemplo:

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)

Usando un alias:

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

En mi investigación, puedo encontrar el resultado en la siguiente velocidad.

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) 

Creo que vale la pena señalar, aunque se mencionó en los comentarios, que en esta situación:

SELECT 1 FROM my_table WHERE *indexed_condition* LIMIT 1

Es superior a:

SELECT * FROM my_table WHERE *indexed_condition* LIMIT 1

Esto se debe a que el índice puede satisfacer la primera consulta, mientras que la segunda requiere una búsqueda de fila (a menos que posiblemente todas las columnas de la tabla estén en el índice utilizado).

Agregar la LIMITcláusula permite que el motor se detenga después de encontrar cualquier fila.

La primera consulta debe ser comparable a:

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

Lo que envía las mismas señales al motor (1 / * no hace ninguna diferencia aquí), pero aún escribiría el 1 para reforzar el hábito al usar EXISTS:

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

Puede tener sentido agregar el EXISTSajuste si necesita un retorno explícito cuando no coinciden las filas.

Sugiero que no lo use Countporque count siempre hace cargas adicionales para el uso de db SELECT 1y devuelve 1 si su registro allí mismo, de lo contrario, devuelve nulo y puede manejarlo.

Una consulta COUNT es más rápida, aunque tal vez no sea notable, pero en lo que respecta a obtener el resultado deseado, ambas deberían ser suficientes.

A veces es bastante útil obtener la clave primaria de incremento automático ( id) de la fila si existe y 0si no.

Así es como se puede hacer esto en una sola consulta:

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

Para las tablas que no son de InnoDB, también puede usar las tablas de esquema de información:

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

Me gustaría ir con COUNT(1). Es más rápido que COUNT(*)porque las COUNT(*)pruebas para ver si al menos una columna en esa fila es! = NULL. No necesita eso, especialmente porque ya tiene una condición (la WHEREcláusula). COUNT(1)en cambio prueba la validez de 1, que siempre es válida y lleva mucho menos tiempo probarla.

O puede insertar una parte sql sin procesar en las condiciones para que tenga 'condiciones' => array ('Member.id NOT IN (SELECCIONE Membership.member_id FROM membresías AS Membership)')

COUNT(*) están optimizados en MySQL, por lo que es probable que la consulta anterior sea más rápida, en general.