¡Hola, analistas y entusiastas de SQL!, hoy vamos a desentrañar uno de los mitos más persistentes en el mundo de las bases de datos:
👉 ¿Es mejor usar COUNT(*) o COUNT(1) en nuestras consultas SQL?
Algunos dicen que COUNT(1) es más rápido porque evita leer todas las columnas, otros aseguran que COUNT(*) es la mejor opción porque es más eficiente. Pero, ¿qué hay de cierto en esto? 🤯 Vamos a analizar cada opción en detalle, con ejemplos prácticos y pruebas de rendimiento, para que puedas tomar una decisión informada la próxima vez que necesites contar registros en tu base de datos.
🔍 ¿Qué hace COUNT en SQL?
Antes de entrar en comparaciones, repasemos cómo funciona COUNT en SQL y qué opciones tenemos:
✅ COUNT(*)
- Cuenta todas las filas de una tabla, sin importar si tienen valores NULL o no.
- Se usa comúnmente para obtener el número total de registros en una tabla.
✅ COUNT(1)
- También cuenta todas las filas de una tabla, pero evalúa la constante 1 en cada fila en lugar de contar todas las columnas.
- La idea detrás de COUNT(1) es que “evita leer columnas innecesarias”, lo que podría mejorar el rendimiento (esto lo analizaremos más adelante).
✅ COUNT(columna)
- Solo cuenta las filas donde la columna especificada NO sea NULL.
- Útil cuando queremos contar solo registros con información válida en una columna específica.
📌 Ejemplo práctico:
Imaginemos que tenemos una tabla Clientes con los siguientes datos:
| ID | Nombre | Ciudad | |
| 1 | Maria | maria@email.com | Madrid |
| 2 | Juan | Null | Sevilla |
| 3 | Pedro | pedro@email.com | Valencia |
Si ejecutamos estas consultas:
SELECT COUNT(*) FROM Clientes; -- Cuenta todas las filas (3)
SELECT COUNT(1) FROM Clientes; -- Cuenta todas las filas (3)
SELECT COUNT(Email) FROM Clientes; -- Solo cuenta los registros donde Email NO es NULL (2)
🔹 Resultado:
- COUNT(*) y COUNT(1) devuelven 3, porque hay tres filas en total.
- COUNT(Email) devuelve 2, porque solo hay dos correos electrónicos registrados.
Ya tenemos claro qué hace COUNT, ahora veamos qué opción es mejor.
📊 Comparación técnica: COUNT(*) vs COUNT(1)
Cuando ejecutamos COUNT(*) o COUNT(1), ¿realmente hay una diferencia en cómo el motor de base de datos procesa la consulta?
SET STATISTICS IO ON;
SET STATISTICS TIME ON;
GO
SELECT COUNT(*) FROM Clientes;
SELECT COUNT(1) FROM Clientes;
GO
SET STATISTICS IO OFF;
SET STATISTICS TIME OFF;
En estos motores modernos, ambas consultas generan el mismo plan de ejecución. Esto significa que no hay diferencia de rendimiento porque el optimizador trata ambas consultas de la misma manera.
📌 ¿Y en bases de datos antiguas?
En versiones más antiguas de MySQL (4.x) y SQL Server 2000, se decía que COUNT(1) era más eficiente porque COUNT(*) leía todas las columnas de la tabla. Pero esto ya no es un problema en versiones recientes, donde los motores optimizan automáticamente la ejecución.
🔥 Conclusión: En bases de datos modernas, NO hay diferencia de rendimiento entre COUNT(*) y COUNT(1).
⚡ ¿Cuándo usar cada opción?
Si ambas opciones son equivalentes en rendimiento en bases de datos modernas, ¿cuál deberíamos usar?
| Opción | Cuando Usarlo | Cuando Evitarlo |
| COUNT(*) | Siempre en bases modernas. El código más claro y estándar | Si trabajas en bases antigua y notas lentitud |
| COUNT(1) | Si te gusta el estilo más explicito (pero no es necesario) | Realmente no aporta beneficios en bases de datos modernas. |
| COUNT(columna) | Si solo quieres valores No nulos | Si necesitas contar todas las filas. |
📌 Ejemplo de uso correcto de COUNT(columna): Si queremos contar cuántos clientes tienen email registrado:
SELECT COUNT(Email) FROM Clientes; -- Solo cuenta clientes con email NO NULL
SELECT COUNT(*) FROM Clientes;
Pruebas de rendimiento en tablas grandes
Para demostrar que COUNT(*) y COUNT(1) funcionan igual en bases modernas, hice una prueba con una tabla de mil de registros en SQL Server 20.
Ejecuté ambas consultas:
Resultados:
🔎 Ambos tienen el mismo tiempo de ejecución, lo que confirma que la optimización del motor SQL los trata igual.
Mitos comunes sobre COUNT(*) y COUNT(1)
❌ Mito: COUNT(1) es más rápido porque solo evalúa una constante.
✅ Realidad: En bases modernas, ambas consultas generan el mismo plan de ejecución.
❌ Mito: COUNT(*) es menos eficiente porque lee todas las columnas.
✅ Realidad: COUNT(*) no lee todas las columnas, solo cuenta las filas en la estructura interna de la tabla.
❌ Mito: COUNT(1) es mejor en todas las bases de datos.
✅ Realidad: Solo tenía una posible ventaja en bases de datos antiguas, pero en versiones recientes no hay diferencia.
Conclusión final
En bases de datos modernas, COUNT(*) y COUNT(1) son equivalentes en rendimiento.
Si necesitas contar valores no nulos, usa COUNT(columna).
Si trabajas en bases de datos antiguas, haz pruebas de rendimiento y usa lo que funcione mejor.
Recomendación: Usa COUNT(*), ya que es más claro, estándar y compatible con todos los motores.
Espero que este artículo te haya aclarado las dudas. ¿Has encontrado diferencias en tu experiencia con COUNT(*) y COUNT(1)? ¡Déjamelo en los comentarios!
Sígueme para más contenido sobre SQL, optimización y análisis de datos. ¡Nos vemos en el próximo blog!