Web.PHP.Bases de Datos.

Conexión.

Para conectarse con una base de datos en php podemos usar dos métodos; MySQLi o PDO.

¿Cual usar?¿Cual es mejor?

La gran diferencia es que MySQLi funciona sólo con Mysql y eso limita un poco cuando queremos usar tipos de bases de datos distintas en un proyecto. En cambio, PDO funciona con 12 tipos de bases de datos, lo cual es mucho menos costoso pasar de un tipo a otro. y no tenemos que reescribir el código.

Yo voy a usar PDO porque es el que aprendí y ya me acostumbre a él.

¿Como conectarse?

#
<?php
$servername = “localhost”; 
$username = “username”; 
$password = “password”; /* Creamos variables para guardar el servidor de la base de datos, el usuario y la contraseña.*/
try {
$conexion = new PDO(“mysql:host=$servername;dbname=miBasedeDatos”, $username, $password); 
/* Creamos una variable para guardar los resultados de la conexión:
- mysql: Sistema de base de datos que vamos a utilizar.
- host=$servername: El servidor de la base de datos.
- dbname=miBasedeDatos: El nombre de la base de datos.
- $username: El usuario de la base de datos.
- $password: La clave del usuario de la base de datos.*/
$conexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 
echo “Conectado correctamente”; 
}
catch(PDOException $e)
{
echo “Fallo en la conexión: “ . $e->getMessage(); 
}
/* Capturamos el error y si ocurriese algo mostraría el mensaje que se encuentra en CATCH.*/
?>

¿Que es eso de try y catch?

Esto se usa para el manejo de excepciones, es decir, es una forma de controlar los errores que puedan ir pasando durante una ejecución. En el lenguaje de los seres humanos viene a decir algo así como “ejecuta lo que hay en TRY y si pasa algún error, para el script y ejecutas lo que hay dentro de CATCH.

Crear una Base de Datos.

#
<?php
// Creamos variables para la conexión de la base de datos.
$servername = “localhost”;
$username = “username”;
$password = “password”;
// Realizamos la conexión.
try {
$conn = new PDO(“mysql:host=$servername”, $username, $password);
 
// Capturo los errores si existieran.
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$sql = “CREATE DATABASE miBasedeDatos”; /* Creo una variable donde almaceno la consulta sql.*/
// Si la consulta no devuelve resultados, lo correcto es usar el método exec.
$conn->exec($sql);
echo “Base de Datos creada correctamente<br>”;
}
// Muestro los errores si los hay.
catch(PDOException $e)
{
echo $sql . “<br>” . $e->getMessage();
}
// Cierro conexión.
$conn = null; / *La conexión siempre deber ser cerrada. Normalmente se cierra automáticamente cuando termina el script, pero si necesitaramos cerrarla manualmente se haría de esta forma. */
?>

Crear Tablas.

Sería exactamente igual que al crear una base de datos, la diferencia está en el instrucción sql que sería la siguiente:

$sql = “CREATE TABLE personas (
id int(6) NOT NULL UNSIGNED AUTOINCREMENT,
nombre varchar(255) NOT NULL,
apellidos varchar(255),
edad int,
CONSTRAINT pk_persona PRIMARY KEY (id)
)”;

Insertar Datos.

Sería exactamente igual que crear tabla, sólo cambiaría la instrucción sql que sería la siguiente:

$sql = “INSERT INTO personas (nombre, apellidos, edad)
VALUES (‘Ismael’, ‘Santos’, 38)”;

Evitando Injección de Código en SQL.

Un ejemplo y vamos analizando:

#
<?php
// Creo variablas para la conexión.
$servername = “localhost”;
$username = “ismael”;
$password = 1234;
$dbname = “miBBDD”;
//Realizamos la conexión.
try {
$conn = new PDO(“mysql:host=$servername;dbname=$dbname”, $username, $password);
// Capturar el error si los hubiera.
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
// Preparando la consulta sql para evitar la injección.
$stmt = $conn->prepare(“INSERT INTO personas(nombre, apellidos, edad) 
VALUES (:nombre, :apellidos, :edad)”); 
/* Creamos una variable donde guardar los resultados llamada stmt. La inserción la hacemos como siempre, la diferencia está en que en el VALUES debemos poner tantos parámetros como campos vayamos a insertar. Los parámetros podemos poner el nombre que queramos pero empezando por “:”. Eso si debemos usarlo más adelante, cuidado con el nombre que le damos.*/
$stmt->bindParam(‘:nombre’, $nombre);
$stmt->bindParam(‘:apellidos’, $apellidos);
$stmt->bindParam(‘:edad’, $edad); 
/* El método bindParam lo que hace es asociar el nombre del parámetro con la variable php que vamos a utilizar para almacenar los valores en la base de datos.*/
 
 //insertar un registro.
$nombre = “ismael”;
$apellidos = “pérez”;
$edad = 23;
$stmt->execute(); 
/* Ahora damos el valor a los campos y usamos el método EXECUTE para realizar la consulta, y ya se encarga él de todo para que no haya errores. Si nos fijamos bien, en realidad hemos hecho como una especie de plantilla para evitar que el usuario introduzca codigo malicioso a través de un campo de formulario.*/
 
 echo “Registro agregado correctamente”;
 }
//Mostrar el mensaje de error si lo hubiera.
catch(PDOException $e)
{
echo “Error: “ . $e->getMessage();
}
// Cerrar conexión.
$conn = null;
?>

En este ejemplo asigno yo el valor a las variables pero normalmente, la preparación de una instrucción sql se hace cuando tenemos un campo de texto donde el usuario introduce el valor y así evitar la injección de código sql.

Si estamos usando etiquetas que no requiere de que el usuario introduzca los datos por teclado, no tiene mucho sentido hacer una preparación para evitar la injección de código. Por ejemplo con etiquetas como select, radio, checkbox ..etc.

Aquí lo hemos hecho con un INSERT, pero sería exactamente igual con un SELECT, DELETE o incluso un UPDATE.

QUERY.

Ahora vamos a ver como se haría de forma normal, es decir, cuando no necesitamos que el usuario meta nada por teclado:

<?php
// Creo variablas para la conexión.
$servername = “localhost”;
$username = “ismael”;
$password = 1234;
$dbname = “miBBDD”;
//Realizamos la conexión.
try {
$conn = new PDO(“mysql:host=$servername;dbname=$dbname”, $username, $password);
// Capturar el error si los hubiera.
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
/*Creamos un variable como parámetro y realizamos la consulta con el método query */
$codigo=2
$resultado=$conn->query(“select * from personas where id>$codigo”);
/* Al ser una consulta nos puede dar más de un registro y php lo que hace es meterlo en una matriz. Ahora toca recorrer esa matriz y mostrar los datos. Vamos a intentar mostrarlo en una tabla simple desde php.*/
echo “<table>
<thead>
<th>ID</th>
<th>NOMBRE</th>
<th>APELLIDOS</th>
<th>EDAD</th>
</thead>
<tbody>
“;
foreach($resultado as $fila){
echo "<tr>
<td>$fila[id]</td>
<td>$fila[nombre]</td>
<td>$fila[apellidos]</td>
<td>$fila[edad]</td>
</tr>";
}
echo “</tbody></table>”;
?>

Creamos una tabla html simple con sus encabezados correspondientes, dentro de la instrucción ECHO y no cerramos el TBODY. Ahora hacemos un bucle para recorrer la matriz, metiendo un TR y cada campo correspondiente en un TD.

¿Por qué Tbody y Th lo hago fuera del bucle? La tabla y los encabezados se hacen sólo una vez, si lo hicieramos dentro del bucle haría encabezados y tablas nuevas por cada fila y eso no es correcto.

Y para finalizar cuando se termina el bucle cierro el tbody y la etiqueta table porque ya no hay más filas que mostrar.

Un arhivo php no deja de ser al mismo tiempo un archivo html, es decir, todo lo que escribamos en él, el servidor lo va a mandar a cliente a través de el navegador web y éste lo va a interpretar como html.

Si nos fijamos bien en el ejemplo, a través de la instrucción echo he mandado una tabla para que se visualice en el navegador. Eso sí, debemos jugar con todo los que nos da php, como bucles, condiciones.., para mostrar los resultados como nos interese.