Conectar PHP Con MySQL

En este tutorial aprenderás a como conectar PHP con MySQL a través de PDO y MySQLi, para acceder y operar tus bases de datos.

Verás cómo abrir la conexión en el servidor MySQL, ejecutar operaciones SELECT, INSERT, DELETE, UPDATE, sentencias preparadas y llamar procedimientos almacenados.

1. Crear Cadena De Conexión

Una cadena de conexión resume en un esquema el servidor, el nombre de la base de datos y el usuario que creará el acceso.

Para empezar, crea un archivo llamado mysql_login.php que almacene los datos de la cadena de conexión.

<?php

$hostname = 'localhost'; // Máquina local 
$database = 'TU_BASE_DE_DATOS';
$username = 'TU_USUARIO';
$password = 'TU_CONTRASEÑA';

Luego incluye este archivo con la sentencia require_once en el archivo donde abriremos la conexión.

Con PDO, abres la conexión con el siguiente código:

<?php

require_once 'mysql_login.php';

// Conectarse a MySQL con extensión PDO
try {
    $con = new PDO('mysql:host=' . $hostname . ';dbname=' . $database,
            $username, $password);
    print "¡Conexión exitosa!";
} catch (PDOException $e) {
    print "¡Error!: " . $e->getMessage();
    die();
}

// Cerrar conexión
$con = null;

Con MySQLi sería de esta forma:

<?php

require_once 'mysql_login.php';

// Conectarse a MySQL con extensión MySQLi 
$mysqli = new mysqli($hostname, $username, $password, $database);
if ($mysqli->connect_errno) {
    echo "¡Error! > (" . $mysqli->connect_errno . ")";
    die();
} else {
    echo "¡Conexión exitosa!";    
}

// Cerrar conexión
$mysqli->close();

En la siguiente tabla verás las características para realizar la conexión con las dos APIs:

Característica	MySQLi	PDO
Crear conexión	new mysqli()	new PDO()
Comprobación de errores	mysqli::$connect_errno	PDOException
Cerrar conexión	mysqli::close()	$con = null

2. Ejecutar Operaciones MySQL

En esta sección se te ilustrará como usar las sentencias UPDATE desde PHP, sobre un ejemplo que consiste en actualizar el nombre de un Profesor, cuyo código es 2 en la base de datos de una Universidad.

Usa el siguiente código de solución para la resolución con PDO:

<?php

// Ejecutar sentencia UPDATE con PDO
$count = $con->exec("UPDATE profesor SET NOMBRE ='Brenda' WHERE id=2");
echo($count . " Filas afectadas");

Para MySQLi esta es la respuesta:

// Ejecutar sentencia UPDATE con MySQLi
if ($mysqli->query("UPDATE profesor SET NOMBRE ='Brenda' WHERE id=2") === TRUE) {
    echo($mysqli->affected_rows . " Filas afectadas");
} else {
    echo "Error al ejecutar el comando:" . $mysqli->error;
}

La siguiente tabla muestra las características de ejecución en cada API:

Característica	MySQLi	PDO
Ejecutar sentencia	mysqli::query()	exec()
Filas afectadas por la sentencia	mysqli::$affected_rows	El retorno de exec()

3. Consultar Base De Datos MySQL

Para este caso MySQLi usa el mismo método anterior para tratar consultas.

En cambio, PDO emplea el método query() para obtener las filas.

El siguiente ejemplo te muestra cómo consultar la tabla aviones del sistema de una Aerolínea hipotética.

Para PDO:

<?php

// Consultar datos con PDO
$query = "SELECT * FROM aviones";

print("<table>");
$resultado = $con->query($query);
foreach ($resultado as $rows) {
    print("<tr>");
    print("<td>" . $rows["id"] . "</td>");
    print("<td>" . $rows["capacidad"] . "</td>");
    print("<td>" . $rows["descripcion"] . "</td>");
    print("</tr>");
}
print("</table>");

$resultado = null;

Con MySQLi:

// Consultar datos con MySQLi
$query = "SELECT * FROM aviones";

$resultado = $mysqli->query($query);
print("<table>");
while ($rows = $resultado->fetch_assoc()) {
    print("<tr>");
    print("<td>" . $rows["id"] . "</td>");
    print("<td>" . $rows["capacidad"] . "</td>");
    print("<td>" . $rows["descripcion"] . "</td>");
    print("</tr>");
}
print("</table>");

$resultado->free();

En resumen:

Característica	MySQLi	PDO
Obtener fila	fetch_result::fetch_assoc()	PDOStatement en bucle foreach
Liberar memoria	mysqli::free()	$resultado = null

4. Sentencias Preparadas

Las sentencias preparadas se usan para ejecutar la misma sentencia repetidamente con gran eficiencia.

Se usa el carácter ? para indicar que un argumento tomará distintos valores, según los datos que asocies para ejecutar la sentencia.

Ejemplo

Supón que has creado un formulario que recibe el nombre, apellido, edad y el correo electrónico de un usuario.

Cuando el usuario de clic en el botón de confirmación estos campos serán guardados en una tabla llamada usuario.

El siguiente código muestra cómo crear la sentencia preparada que resuelve esta característica en PDO:

<?php

// Sentencia preparada en PDO
$cmd = $con->prepare('INSERT INTO usuario VALUES(NULL,?,?,?,?)');
$cmd->execute(array($nombre, $apellido, $edad, $email));

Para MySQLi el equivalente es el siguiente:

//Sentencia preparada con MySQLi
if ($stmt = $mysqli->prepare("INSERT INTO usuario VALUES(NULL,?,?,?,?)")) {

    // Ligar parámetros para marcadores 
    $stmt->bind_param("ssds", $nombre, $apellido, $edad, $email);

    // Ejecutar la consulta 
    $stmt->execute();

    // Cerrar sentencia
    $stmt->close();
} else {
    echo "Error al ejecutar la sentencia preparada" . $mysqli->error;
}

Aquí hay una tabla con el resumen de las sentencias preparadas con ambas APIs:

Acción	MySQLi	PDO
Preparar sentencia	mysqli_stmt::prepare() Argumentos con ? o etiqueta :nombre.	PDO::prepare()
Ligar parámetros a la sentencia	mysqli_stmt::bind_param() El primer parámetro es un string con los tipos (i entero, d float, s string y b Tipo blob)	PDOStatement::bindParam()
Ejecuta un comando preparado.	mysqli_stmt::execute()	PDOStatement::execute() Pasa los parámetros aquí como array
Obtener resultados	mysqli_stmt::get_result()	PDOStatement::fetch()

5. Ejecutar Un Procedimiento Almacenado

Ejecutar un procedimiento con las extensiones no requiere métodos nuevos ni adornos adicionales.

Se hace exactamente lo mismo que has venido estudiando en cada complemento.

Lo único que debes tener en cuenta es si el procedimiento devuelve una tabla o solo afecta la base de datos.

Dependiendo de esa situación elegirás el método apropiado.

Ejemplo:

A continuación veremos la invocación de un procedimiento que devuelve las estadísticas de un Curso Online realizado por Estudiantes.

Llamaremos al procedimiento sp_estadistica_curso. Se debe considerar que este método recibe como parámetro de entrada el ID del curso:

<?php

// Llamar procedimiento almacenado con PDO
$proc = $con->prepare('CALL sp_clientes_edad(?)');
$proc->bindParam(1, $var, PDO::PARAM_INT);
$proc->execute();

print("<table>");
while ($res = $proc->fetch(PDO::FETCH_OBJ)) {
    print("<tr>");
    print("<td>" . $res->no_alumnos . "</td>");
    print("<td>" . $res->nota_media . "</td>");
    print("<td>" . $res->nota_max . "</td>");
    print("<td>" . $res->nota_min . "</td>");
    print("</tr>");
}
print("</table>");

En MySQLi sería así:

<?php

// Llamar procedimiento almacenado con MySQLi
if ($stmt = $mysqli->prepare("CALL sp_estadistica_curso(?)")) {
    // Ligar parámetros para marcadores
    $stmt->bind_param("d", $Id_curso);

    // Ejecutar la consulta
    $stmt->execute();
    $resultado = $stmt->get_result();

    print("<table>");
    while ($rows = $resultado->fetch_assoc()) {
        print("<tr>");
        print("<td>" . $rows["NO_ALUMNOS"]);
        print("<td>" . $rows["NOTA_MEDIA"]);
        print("<td>" . $rows["NOTA_MAX"]);
        print("<td>" . $rows["NOTA_MIN"]);
        print("</tr>");
    }
    print("</table>");

    // Cerrar sentencia
    $stmt->close();
} else {
    echo "Error al ejecutar el procedimiento" . $mysqli->error;
} 

Usa la sentencia CALL y ejecuta normalmente el procedimiento, como si se tratase de un comando regular.