Contar Filas en PHP con MySQLi

En el desarrollo de aplicaciones web con PHP, interactuar con bases de datos es una tarea fundamental. Una de las operaciones más comunes es determinar cuántos registros cumplen con ciertos criterios, es decir, contar las filas resultantes de una consulta SQL. Saber el número de filas es útil para diversas funcionalidades, como la paginación, mostrar estadísticas, o simplemente verificar si existen datos.

Existen principalmente dos enfoques para lograr esto cuando trabajamos con MySQL y la extensión MySQLi en PHP: utilizando una función de PHP sobre el resultado de la consulta, o dejando que la propia base de datos realice el conteo.

Usando mysqli_num_rows() en PHP

La función mysqli_num_rows() es una función integrada en PHP que forma parte de la extensión MySQLi. Su propósito es devolver el número de filas en un conjunto de resultados obtenido de una consulta SELECT.

Esta función es particularmente útil después de ejecutar una consulta SELECT y obtener un recurso de resultado. Te permite saber cuántas filas fueron devueltas por esa consulta específica antes de comenzar a iterar sobre ellas o si simplemente quieres saber si hay resultados.

Sintaxis y Parámetros

La sintaxis básica de mysqli_num_rows() es la siguiente:

mysqli_num_rows($resultado);

Esta función acepta un único parámetro obligatorio:

• $resultado: Es el conjunto de resultados devuelto por una llamada exitosa a mysqli_query() (o funciones similares que retornen un resultado, como mysqli_store_result()). Es crucial que mysqli_query() haya sido ejecutada previamente y haya retornado un recurso de resultado válido y no false (que indicaría un error en la consulta).

Valor de Retorno

mysqli_num_rows() retorna un número entero que representa la cantidad de filas en el conjunto de resultados. Si la consulta se ejecutó correctamente pero no encontró ninguna fila (un resultado válido pero vacío), la función retornará 0. Retornará false únicamente si ocurre un error interno o si el parámetro proporcionado no es un recurso de resultado válido.

Ejemplo Práctico con mysqli_num_rows()

Veamos cómo implementar mysqli_num_rows() en un script PHP. Supongamos que tenemos una tabla llamada usuarios en una base de datos y queremos saber cuántos usuarios hay.

Primero, necesitamos establecer una conexión a la base de datos. Luego, ejecutamos nuestra consulta SELECT y, si es exitosa, usamos mysqli_num_rows().

<?php
// Configuración de la conexión a la base de datos
$servidor = "localhost";
$usuario = "tu_usuario";
$contrasena = "tu_contrasena";
$base_de_datos = "tu_base_de_datos";

// Intentar establecer la conexión
$conexion = mysqli_connect($servidor, $usuario, $contrasena, $base_de_datos);

// Verificar la conexión
if (mysqli_connect_errno()) {
 die("Error de conexión a la base de datos: " . mysqli_connect_error());
}

// Consulta SQL para seleccionar todos los usuarios
$consulta = "SELECT id, nombre, email FROM usuarios";

// Ejecutar la consulta
$resultado = mysqli_query($conexion, $consulta);

// Verificar si la consulta fue exitosa
if ($resultado) {
 // Usar mysqli_num_rows() para obtener el número de filas
 $numero_filas = mysqli_num_rows($resultado);

 // Mostrar el resultado
 if ($numero_filas > 0) {
 echo "La consulta devolvió " . $numero_filas . " filas.";
 // Aquí podrías iterar sobre los resultados si fuera necesario
 /*
 while ($fila = mysqli_fetch_assoc($resultado)) {
 // Procesar cada fila
 }
 */
 } else {
 echo "La consulta no devolvió filas.";
 }

 // Liberar el conjunto de resultados
 mysqli_free_result($resultado);
} else {
 // Manejar el error de la consulta
 echo "Error al ejecutar la consulta: " . mysqli_error($conexion);
}

// Cerrar la conexión
mysqli_close($conexion);
?>

En este ejemplo, primero establecemos la conexión. Luego, definimos y ejecutamos la consulta SELECT. Si mysqli_query() no retorna false (indicando éxito), procedemos a llamar a mysqli_num_rows() con el recurso $resultado. El valor retornado se almacena en $numero_filas, que luego podemos usar para mostrar un mensaje o tomar decisiones lógicas.

Consideraciones sobre el Rendimiento de mysqli_num_rows()

Es importante entender cómo funciona mysqli_num_rows() internamente. Cuando ejecutas una consulta con mysqli_query(), MySQLi por defecto almacena todo el conjunto de resultados en la memoria del servidor PHP (esto se conoce como almacenamiento en buffer o buffered queries). mysqli_num_rows() simplemente cuenta cuántas filas hay en este conjunto almacenado en memoria.

Esto es eficiente para conjuntos de resultados pequeños o medianos. Sin embargo, si tu consulta puede devolver una cantidad *muy* grande de filas (cientos de miles o millones), almacenar todo ese resultado en la memoria del servidor PHP puede consumir una cantidad considerable de recursos (memoria RAM) y afectar el rendimiento, e incluso causar que el script se quede sin memoria. En tales casos, usar mysqli_num_rows() *después* de obtener un resultado masivo puede no ser la estrategia más óptima.

Alternativa: Usando la Función COUNT(*) de SQL

Una alternativa muy común y a menudo más eficiente, especialmente para tablas grandes o cuando *solo* necesitas el número de filas y no los datos en sí, es utilizar la función agregada COUNT(*) directamente en tu consulta SQL.

La función COUNT(*) es una función estándar de SQL que cuenta el número de filas que cumplen los criterios especificados en la cláusula WHERE de tu consulta. La base de datos (MySQL en este caso) realiza el conteo y devuelve un *único* valor: el total de filas.

Ventajas de Usar COUNT(*)

• Rendimiento: Para conjuntos de datos grandes, es significativamente más rápido porque la base de datos está optimizada para este tipo de operaciones y no necesita enviar todas las filas a PHP, solo un único número.
• Uso de Recursos: Consume mucha menos memoria en el servidor PHP, ya que solo se recibe un valor numérico, no un conjunto de resultados completo.

Ejemplo Práctico con COUNT(*)

Para usar COUNT(*), la consulta SQL cambia. En lugar de seleccionar las columnas, seleccionamos el resultado de COUNT(*). Luego, en PHP, ejecutamos esta consulta y recuperamos el único valor devuelto.

<?php
// Configuración de la conexión (igual que antes)
$servidor = "localhost";
$usuario = "tu_usuario";
$contrasena = "tu_contrasena";
$base_de_datos = "tu_base_de_datos";

$conexion = mysqli_connect($servidor, $usuario, $contrasena, $base_de_datos);

if (mysqli_connect_errno()) {
 die("Error de conexión a la base de datos: " . mysqli_connect_error());
}

// Consulta SQL para contar el número total de usuarios
// Podemos asignar un alias al resultado para acceder a él fácilmente
$consulta_conteo = "SELECT COUNT(*) AS total_usuarios FROM usuarios";

// Ejecutar la consulta de conteo
$resultado_conteo = mysqli_query($conexion, $consulta_conteo);

// Verificar si la consulta fue exitosa
if ($resultado_conteo) {
 // Obtener la fila de resultado (solo hay una)
 $fila_conteo = mysqli_fetch_assoc($resultado_conteo);

 // Acceder al valor del conteo usando el alias
 $numero_filas = $fila_conteo['total_usuarios'];

 // Mostrar el resultado
 echo "El número total de usuarios es: " . $numero_filas . ".";

 // Liberar el conjunto de resultados (aunque es pequeño, es buena práctica)
 mysqli_free_result($resultado_conteo);
} else {
 // Manejar el error de la consulta
 echo "Error al ejecutar la consulta de conteo: " . mysqli_error($conexion);
}

// Cerrar la conexión
mysqli_close($conexion);
?>

En este caso, la consulta SELECT COUNT(*) AS total_usuarios FROM usuarios le pide a la base de datos que cuente las filas y que nombre esa cuenta como total_usuarios. La consulta devuelve un conjunto de resultados con una sola fila y una sola columna. Utilizamos mysqli_fetch_assoc() (o mysqli_fetch_row()) para obtener esa fila y luego accedemos al valor del conteo usando el alias total_usuarios.

Comparativa: mysqli_num_rows() vs. COUNT(*)

Ambos métodos sirven para contar filas, pero tienen usos y características diferentes. Aquí tienes una tabla comparativa:

En resumen, si ya vas a obtener todos los datos de la consulta para mostrarlos o procesarlos, usar mysqli_num_rows() es conveniente para saber cuántos resultados obtuviste. Si tu único objetivo es saber cuántas filas hay que cumplen un criterio (especialmente en tablas grandes), usar COUNT(*) es casi siempre la opción más eficiente.

Manejo de Errores

Independientemente del método que elijas, es crucial manejar los errores. Siempre verifica el resultado de mysqli_query(). Si devuelve false, significa que hubo un error en la consulta SQL o en la comunicación con la base de datos. Intentar usar mysqli_num_rows() o mysqli_fetch_assoc() en un resultado que es false generará errores en tu script PHP. Utiliza mysqli_error($conexion) para obtener detalles sobre el error.

Preguntas Frecuentes

Aquí respondemos algunas dudas comunes sobre cómo contar filas en PHP con MySQLi.

¿Cuál es la diferencia principal entre mysqli_num_rows() y usar COUNT(*) en SQL?

La principal diferencia es quién realiza el conteo y qué datos se transfieren. mysqli_num_rows() cuenta las filas *después* de que PHP ha recibido todo el conjunto de resultados de la base de datos. COUNT(*) le pide a la base de datos que haga el conteo y solo envía el número total a PHP. Esto último es más eficiente para tablas grandes.

¿Cuándo debería usar mysqli_num_rows()?

Úsala cuando ya has ejecutado una consulta SELECT para obtener datos y necesitas saber cuántas filas tiene el resultado que ya está (o se está por) transferir a PHP. Por ejemplo, para mostrar "Mostrando X resultados" o para decidir si mostrar una tabla o un mensaje de "No se encontraron resultados".

¿Cuándo debería usar COUNT(*)?

Úsala cuando *solo* necesitas saber cuántas filas cumplen una condición y no necesitas recuperar los datos de esas filas. Es ideal para la paginación (para saber el número total de páginas posibles) o para obtener estadísticas de conteo rápidas sin cargar todos los datos en PHP.

¿mysqli_num_rows() funciona si uso mysqli_use_result()?

No directamente como esperas. mysqli_use_result() inicia un resultado no almacenado en buffer (unbuffered result). Con resultados no almacenados en buffer, las filas se obtienen del servidor MySQL una por una a medida que las solicitas. MySQLi no sabe el número total de filas de antemano en este modo. mysqli_num_rows() solo funciona correctamente con resultados almacenados en buffer (el modo por defecto de mysqli_query()).

¿Qué pasa si la consulta SQL falla?

Si mysqli_query() devuelve false (indicando un error en la consulta), no debes pasar este valor a mysqli_num_rows(). Debes verificar si mysqli_query() tuvo éxito antes de llamar a mysqli_num_rows(). De lo contrario, PHP generará un error.

¿Existe un límite en el número de filas que mysqli_num_rows() puede contar?

Técnicamente, no hay un límite impuesto por la función en sí, pero el límite práctico está dado por la memoria disponible en el servidor PHP. Si el conjunto de resultados es tan grande que no cabe en la memoria, la operación de mysqli_query() o mysqli_num_rows() podría fallar debido a falta de memoria.

Conclusión

Contar filas en una base de datos desde PHP con MySQLi es una tarea común con dos enfoques principales. La función mysqli_num_rows() es sencilla de usar y adecuada cuando ya has obtenido o vas a obtener el conjunto completo de resultados en PHP. Sin embargo, para obtener solo el conteo, especialmente en tablas grandes, la función SQL COUNT(*) es generalmente la opción más eficiente y recomendada, ya que aprovecha la capacidad de la base de datos para realizar la agregación y minimiza la transferencia de datos y el uso de memoria en el servidor PHP. Elegir el método correcto dependerá de tu caso de uso específico y las consideraciones de rendimiento.

Si quieres conocer otros artículos parecidos a Contar Filas en PHP con MySQLi puedes visitar la categoría Bases de datos.