PHP: Seleccionar BD y Obtener Datos con MySQLi

Conectar una aplicación web desarrollada en PHP a una base de datos MySQL es un paso fundamental para construir sistemas dinámicos y robustos. Una vez establecida la conexión con el servidor de base de datos, es crucial saber cómo seleccionar la base de datos específica con la que deseas trabajar y, posteriormente, cómo extraer los datos necesarios para mostrarlos o procesarlos en tu aplicación. La extensión MySQLi (MySQL Improved) en PHP ofrece una interfaz mejorada para interactuar con bases de datos MySQL, proporcionando tanto un estilo procedural como uno orientado a objetos.

Este artículo te guiará a través de los procesos esenciales: seleccionar la base de datos predeterminada para tu conexión y ejecutar consultas para obtener datos, centrándonos en la potencia y flexibilidad que MySQLi te ofrece.

Estableciendo Conexión y Seleccionando la Base de Datos

El primer paso, como siempre, es establecer una conexión con el servidor MySQL. Esto se logra proporcionando la dirección del servidor (generalmente 'localhost'), el nombre de usuario, la contraseña y, opcionalmente, el nombre de la base de datos inicial. Si no especificas la base de datos al conectar, puedes seleccionarla posteriormente.

La extensión MySQLi permite hacerlo de varias maneras. Si utilizas el estilo orientado a objetos, puedes especificar la base de datos directamente en el constructor o usar el método select_db() después de conectar. Si prefieres el estilo procedural, usas la función mysqli_connect() o mysqli_select_db().

Aquí tienes un ejemplo usando el estilo orientado a objetos para conectar y luego cambiar la base de datos seleccionada:

<?php
$mysqli = new mysqli("localhost","my_user","my_password","my_db");

// Verificar conexión
if ($mysqli -> connect_errno) {
 echo "Failed to connect to MySQL: " . $mysqli -> connect_error;
 exit();
}

// Mostrar base de datos actual (opcional)
if ($result = $mysqli -> query("SELECT DATABASE()")) {
 $row = $result -> fetch_row();
 echo "Base de datos predeterminada es: " . $row[0] . "<br>";
 $result -> close();
}

// Cambiar a otra base de datos
if ($mysqli -> select_db("otra_db")) {
 echo "Base de datos cambiada a: otra_db" . "<br>";
} else {
 echo "Error al cambiar de base de datos: " . $mysqli->error . "<br>";
}

// Mostrar base de datos actual nuevamente
if ($result = $mysqli -> query("SELECT DATABASE()")) {
 $row = $result -> fetch_row();
 echo "Base de datos actual es: " . $row[0] . "<br>";
 $result -> close();
}

$mysqli -> close();
?>

En este ejemplo, primero conectamos especificando "my_db", luego usamos select_db("otra_db") para cambiar la base de datos activa para las operaciones subsiguientes en esa conexión. Es una buena práctica verificar siempre si la conexión fue exitosa y manejar posibles errores.

¿Qué es una Consulta SELECT?

La consulta SELECT es uno de los comandos más fundamentales y utilizados en SQL (Structured Query Language). Su propósito principal es recuperar datos de una o más tablas en una base de datos. Cuando ejecutas una consulta SELECT, el resultado es un conjunto de registros, que a menudo se denomina "conjunto de resultados" (result-set). Este conjunto de resultados contiene las filas que cumplen con los criterios especificados en la consulta.

La sintaxis básica de una consulta SELECT es:

SELECT columna1, columna2, ...
FROM nombre_tabla;

Si deseas seleccionar todas las columnas de una tabla, puedes usar el asterisco (*):

SELECT *
FROM nombre_tabla;

Sin condiciones adicionales, una consulta SELECT simple como esta devolverá todas las filas de la tabla especificada.

Ejecutando Consultas SELECT con MySQLi

Para ejecutar una consulta SQL, incluida SELECT, en PHP usando MySQLi, utilizas la función o método query(). Este es el corazón de la interacción entre tu script PHP y la base de datos para operaciones que no sean sentencias preparadas (aunque query() también puede ejecutar sentencias preparadas, es más común usar los métodos prepare() y execute() para eso).

La función query() toma la conexión a la base de datos y la cadena de la consulta SQL como argumentos. Opcionalmente, puede aceptar un modo de resultado.

Sintaxis de query()

Estilo Orientado a Objetos:

$mysqli->query(query, resultmode)

Estilo Procedural:

mysqli_query(connection, query, resultmode)

Donde:

• connection (Requerido): Especifica la conexión MySQL a usar.
• query (Requerido): Especifica la cadena de la consulta SQL.
• resultmode (Opcional): Una constante que puede ser MYSQLI_USE_RESULT (para recuperar grandes cantidades de datos de forma eficiente, fila a fila) o MYSQLI_STORE_RESULT (el valor por defecto, almacena todo el resultado en memoria del servidor).

El valor de retorno de query() es crucial:

• Para consultas exitosas como SELECT, SHOW, DESCRIBE o EXPLAIN, devuelve un objeto mysqli_result.
• Para otras consultas exitosas (INSERT, UPDATE, DELETE, DROP, etc.), devuelve TRUE.
• En caso de fallo, devuelve FALSE.

Es fundamental verificar el valor de retorno para determinar si la consulta fue exitosa y, en el caso de SELECT, si se obtuvo un conjunto de resultados válido.

Obteniendo Datos del Conjunto de Resultados

Una vez que query() devuelve un objeto mysqli_result para una consulta SELECT, necesitas métodos para extraer las filas de datos de este objeto. MySQLi proporciona varios métodos para esto:

• fetch_row(): Recupera una fila del conjunto de resultados como un array numérico.
• fetch_array(): Recupera una fila como un array asociativo, numérico o ambos.
• fetch_assoc(): Recupera una fila como un array asociativo (los nombres de las columnas son las claves).
• fetch_object(): Recupera una fila como un objeto.
• fetch_all(): Recupera todas las filas restantes del conjunto de resultados como un array de arrays asociativos, numéricos o ambos.

Generalmente, se utiliza un bucle (como while) para iterar sobre el conjunto de resultados y procesar cada fila individualmente hasta que no queden más filas.

Aquí tienes un ejemplo completo que muestra cómo conectar, seleccionar una base de datos y obtener datos de una tabla usando el estilo procedural de MySQLi, similar al ejemplo proporcionado:

<?php
if(isset($_POST['Submit1'])) {
 $username = "username"; // Reemplaza con tu usuario
 $password = "password"; // Reemplaza con tu contraseña
 $hostname = "localhost";
 $database = "School"; // La base de datos a la que te conectarás

 // Conexión a la base de datos mysql
 $dbhandle = mysqli_connect($hostname, $username, $password, $database);

 // Verificar conexión
 if (!$dbhandle) {
 die("Error de conexión: " . mysqli_connect_error());
 }

 // Construir la consulta SELECT
 $sql = "SELECT ID, Name, City FROM StudentMst";
 if(!empty($_POST["id"])) {
 // Si se proporcionó un ID, añadir la cláusula WHERE
 // ¡CUIDADO! Este código es vulnerable a inyección SQL. 
 // Usa sentencias preparadas en producción.
 $student_id = $_POST["id"];
 $sql .= " WHERE ID = " . $student_id;
 }

 // Ejecutar la consulta
 $result = mysqli_query($dbhandle, $sql);

 // Verificar si la consulta fue exitosa
 if ($result) {
 // Verificar si se encontraron filas
 if (mysqli_num_rows($result) > 0) {
 // Obtener y mostrar los datos
 while ($row = mysqli_fetch_array($result)) {
 echo "ID:" .$row['ID']. " Nombre:".$row['Name']. " Ciudad: ". $row['City']."<br>";
 }
 } else {
 echo "No se encontraron resultados.";
 }
 // Liberar el conjunto de resultados
 mysqli_free_result($result);
 } else {
 echo "Error en la consulta: " . mysqli_error($dbhandle);
 }

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

Este código muestra cómo se maneja una consulta SELECT básica. Primero se establece la conexión, luego se construye la consulta (opcionalmente con una cláusula WHERE), se ejecuta con mysqli_query(), se verifica el resultado y se itera sobre las filas usando mysqli_fetch_array() para mostrar los datos. Finalmente, se libera la memoria del conjunto de resultados y se cierra la conexión.

Cláusulas Comunes en Consultas SELECT

Las consultas SELECT pueden volverse mucho más complejas y potentes utilizando diversas cláusulas para filtrar, agrupar y ordenar los datos. Algunas de las cláusulas más comunes incluyen:

• WHERE: Utilizada para filtrar registros basándose en una condición. Solo las filas que cumplen la condición son incluidas en el resultado.
• GROUP BY: Agrupa filas que tienen los mismos valores en columnas específicas en filas de resumen, como para calcular agregados (suma, promedio, conteo, etc.).
• HAVING: Similar a WHERE, pero se utiliza para filtrar los resultados de un GROUP BY basándose en una condición sobre los valores agregados.
• ORDER BY: Se usa para ordenar el conjunto de resultados en orden ascendente (ASC) o descendente (DESC) según una o más columnas.
• AS: Se utiliza para asignar un alias temporal a una columna o a una tabla en el conjunto de resultados. Esto puede hacer que los nombres de columna sean más legibles o simplificar consultas complejas.

Por ejemplo, para obtener el número de estudiantes por ciudad, ordenado por el conteo descendente:

SELECT City, COUNT(ID) AS NumeroEstudiantes
FROM StudentMst
GROUP BY City
ORDER BY NumeroEstudiantes DESC;

Este tipo de consultas avanzadas permite extraer información muy específica y resumida de tu base de datos.

Manejo de Errores

Un aspecto crucial al trabajar con bases de datos en PHP es el manejo de errores. Debes verificar si la conexión falló (mysqli_connect_errno o $mysqli->connect_errno) y si las consultas fallaron (el retorno de query() o mysqli_query() es FALSE). En caso de error, puedes obtener información detallada utilizando mysqli_connect_error(), mysqli_error(), $mysqli->connect_error o $mysqli->error.

Implementar un manejo de errores adecuado te ayuda a depurar problemas rápidamente y a evitar que se muestren mensajes de error sensibles a los usuarios finales en un entorno de producción.

Comparación MySQLi Procedural vs. Orientado a Objetos

MySQLi ofrece dos estilos para interactuar con la base de datos. Ambos son válidos y en gran medida equivalentes en funcionalidad, pero tienen sintaxis diferentes:

La elección entre un estilo u otro a menudo depende de la preferencia personal o de los estándares de codificación del proyecto. El estilo orientado a objetos tiende a ser más modular y fácil de leer para algunos desarrolladores.

Consideraciones de Seguridad

Es vital destacar la importancia de la seguridad al construir consultas SQL basadas en entradas de usuario (como el ejemplo que obtiene un ID del formulario). El ejemplo básico proporcionado es vulnerable a inyección SQL. Para prevenir esto, siempre debes usar sentencias preparadas (Prepared Statements) con MySQLi (usando prepare() y bind_param()) o filtrar y escapar adecuadamente todas las entradas de usuario antes de incluirlas en una consulta.

Preguntas Frecuentes sobre Selección y Consulta de Datos en PHP/MySQL

¿Cuál es la diferencia entre mysqli_query() y mysqli_fetch_array()?

mysqli_query() ejecuta la consulta SQL en la base de datos y, para consultas SELECT, devuelve un objeto que representa el conjunto de resultados. mysqli_fetch_array() es uno de los métodos (o funciones en el estilo procedural) que se utiliza para extraer una sola fila de datos de ese conjunto de resultados devuelto por mysqli_query().

¿Necesito usar select_db() si ya especifiqué la base de datos al conectar?

No, si ya proporcionaste el nombre de la base de datos en la función mysqli_connect() o en el constructor new mysqli() y no necesitas cambiar a otra base de datos durante la vida de esa conexión, no es necesario llamar a select_db().

¿Cómo sé cuántas filas devolvió mi consulta SELECT?

Después de ejecutar una consulta SELECT con éxito, puedes usar mysqli_num_rows($result) (procedural) o $result->num_rows (orientado a objetos), donde $result es el objeto mysqli_result devuelto por query().

¿Qué debo hacer con el conjunto de resultados después de haber procesado los datos?

Es una buena práctica liberar la memoria asociada al conjunto de resultados, especialmente para consultas grandes. Puedes hacerlo con mysqli_free_result($result) (procedural) o $result->free_result() (orientado a objetos).

¿Cuándo debo usar sentencias preparadas en lugar de query()?

Debes usar sentencias preparadas siempre que tu consulta incluya valores que provengan de fuentes externas (como entradas de usuario, variables de sesión, etc.). Las sentencias preparadas son la forma más segura y eficiente de ejecutar consultas repetidamente o con datos variables, ya que separan la lógica SQL de los datos, previniendo ataques de inyección SQL.

Conclusión

Dominar la selección de bases de datos y la ejecución de consultas SELECT es esencial para cualquier desarrollador PHP que trabaje con MySQL. La extensión MySQLi proporciona las herramientas necesarias, ya sea a través de su interfaz procedural o la orientada a objetos. Al entender cómo conectar, seleccionar la base de datos correcta, ejecutar consultas con query() y procesar los resultados con métodos como fetch_array(), puedes construir aplicaciones web dinámicas que interactúan eficazmente con los datos almacenados. Recuerda siempre priorizar la seguridad utilizando sentencias preparadas para proteger tu aplicación contra vulnerabilidades como la inyección SQL.

Si quieres conocer otros artículos parecidos a PHP: Seleccionar BD y Obtener Datos con MySQLi puedes visitar la categoría Bases de datos.