11
Curso PHP Básico Escuela de Administración Pública
PHP y
MySQL
11.1. Introducción
PHP soporta muchos de los gestores de bases de datos relacionales existentes en el mercado. Las dos alternativas
más comunes son ProstgreSQL y MySQL. Aunque PostgreSQL es mucho mejor en cuanto a características y
funciones soportadas del SQL 92 estándar, MySQL se ha hecho más popular en el ambiente de los servidores web.
Cuando los servidores web ofrecen su servicio como LAMP se refieren a Linux + Apache + MySQL + PHP.
Este tema cubre las operaciones más comunes que los desarrolladores de PHP pueden hacer con MySQL, desde
recuperar o modificar datos, buscar textos o hacer una copia de seguridad de la base de datos.
Para seguir los ejemplos debes crear una pequeña base de datos con una tabla. En el gestor de base de datos que
codeanywhere pone a nuestra disposición, phpMyAdmin, puedes crear una base de datos y una tabla; o ejecutar
directamente las siguientes sentencias en el editor de SQL:
Nota: Para acceder a phpMyAdmin haz clic con el botón derecho del ratón en el nombre
de la conexión y selecciona la opción Info para que muestre en una pestaña la
información del contenedor de codeanywhere. Haz clic en el último enlace para acceder
a phpMyAdmin.
CREATE DATABASE `compras`;
USE `compras`;
CREATE TABLE `usuarios` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`nombre` varchar(255) DEFAULT NULL,
`apellidos` varchar(255) DEFAULT NULL,
`cuenta` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
INSERT INTO `usuarios` (`id`, `nombre`, `apellidos`, `cuenta`)
VALUES
(1,'Luis Miguel','Cabezas Granado',0),
(2,'Francisco José','González Lozano',0),
(3,'María Fernanda','Jaramillo Polo',0);
11.2. Extensiones MySQL
Una extensión en PHP es una API de programación que resuelve un determinado tipo de problema. Las
extensiones de MySQL resuelven perfectamente la interactividad con este gestor de bases de datos. Si utilizas una
versión de MySQL superior a la 4.1.3 necesitarás utilizar la extensión mysqli para sacarle un mayor provecho a
todas las funcionalidades:
• Interfaz orientado a objetos.
• Soporte para sentencias preparadas.
1
Curso PHP Básico Escuela de Administración Pública
• Múltiples sentencias.
• Transacciones.
• Capacidades de depuración avanzadas.
En el Anexo I se explica la instalación de PHP y MySQL en los distintos sistemas operativos. Todas ellas ya
añaden la extensión mysqli.
11.3. Conexión a MySQL
Es un proceso muy simple que consta de dos pasos:
• Se conecta con el servidor de MySQL.
• Se solicita la conexión a una base de datos específica.
Es importante recordar que MySQL es un servidor que puede estar alojado en el mismo ordenador que PHP, o
en otro diferente. Por eso, la conexión necesita añadir un parámetro para incluir la dirección IP o el nombre del host
del servidor de bases de datos. Para conectar a MySQL es necesario enviar como parámetros la dirección del
servidor, el usuario y la contraseña.
<?php
$servidor = "localhost";
$usuario = "root";
$pass = "";
$base_datos = "compras";
//Conexión al servidor de bases de datos
$descriptor = mysqli_connect($servidor, $usuario, $pass, $base_datos)
or die("Imposible conectar");
//Se cierra la conexión cuando terminemos
mysqli_close($descriptor);
?>
Conexión establecida.
La función mysqli_connect() permite conectar a un servidor. En este caso, hemos puesto como servidor a
localhost porque estamos utilizando el sistema de codeanywhere para hacer las pruebas.
Otra cuestión importante es que el servidor MySQL puede almacenar varias bases de datos de un mismo usuario,
por eso tenemos que añadirla a la función mysqli_connect(), para seleccionar la que queremos utilizar.
Por último, tenemos la función mysqli_close() que se encarga de cerrar una conexión con el servidor. Por lo
general, cuando la conexión no es persistente, no es necesario cerrar explícitamente la conexión, de eso ya se encarga
PHP por nosotros al terminar de ejecutar el script. Esto se hace así por razones de rendimiento.
El ejemplo siguiente muestra cómo se puede crear una clase reutilizable en todos los proyectos que sirva para
conectarse a una base de datos:
<?php
class ServidorBaseDatos
{
private $servidor;
private $usuario;
private $pass;
private $baseDatos;
private $descriptor;
private $resultado;
function __construct($servidor, $usuario, $pass, $baseDatos){
$this->servidor = $servidor;
$this->usuario = $usuario;
$this->pass = $pass;
$this->baseDatos = $baseDatos;
$this->conectarBaseDatos();
}
2
Curso PHP Básico Escuela de Administración Pública
private function conectarBaseDatos() {
$this->descriptor = mysqli_connect(
$this->servidor,
$this->usuario,
$this->pass,
$this->baseDatos)or die("Imposible conectar");
}
}
?>
Probamos de nuevo la conexión utilizando esta clase
<?
require_once "[Link]";
$servidor = "localhost";
$usuario = "root";
$pass = "";
$baseDatos = "compras";
$usuario = new ServidorBaseDatos($servidor, $usuario, $pass, $baseDatos);
?>
Conexión Establecida
11.4. Seleccionar datos
Existen diferentes formas de generar consultas desde MySQL, pero la más usada es mysqli_query(). Vamos a
añadir dos métodos nuevos a la definición de la clase anterior para que nos puedan servir en otras aplicaciones.
public function consulta($consulta){
$this->resultado = mysqli_query($this->descriptor, $consulta);
}
public function extraerRegistro(){
if($fila = mysqli_fetch_array($this->resultado, MYSQLI_ASSOC)){
return $fila;
}else{
return false;
}
}
El método consulta() recibe una sentencia SQL que debe ejecutarse en la base de datos apuntada por el
descriptor $this->descriptor. El método extraerRegistro() comprueba con la función
mysql_fetch_array() si existen registros en el resultado de la consulta. En caso afirmativo, devuelve un array
con los datos de ese registro.
En el tema de los arrays vimos que un registro pasado como array permitía acceder a las columnas mediante un
índice numérico ($fila[0]) o mediante el nombre de la columna ($fila["id_usuario"]). La directiva
MYSQLI_ ASSOC elimina la posibilidad de extraer los datos con un índice numérico, mejorando la recuperación en
los bucles del foreach. Graba la clase anterior con los dos nuevos métodos en un fichero llamado
[Link] y el siguiente ejemplo en un nuevo fichero. Así independizaremos las clases del código que
las utiliza:
<?php
$servidor = "localhost";
$usuario = "root";
$pass = "";
$baseDatos = "compras";
//Primero se añade el fichero que contiene la clase
require_once "[Link]";
$usuario = new ServidorBaseDatos($servidor, $usuario, $pass, $baseDatos);
$usuario->consulta("select * from usuarios");
while($fila = $usuario->extraerRegistro()){
3
Curso PHP Básico Escuela de Administración Pública
foreach($fila as $Indice => $valor){
echo "$Indice: $valor<br>";
}
echo "<br>";
}
?>
El código anterior recupera la clase del fichero [Link] e inicializa las variables necesarias para
conectar con la base de datos. También podemos utilizar un fichero de configuración para almacenar los datos de la
conexión. La variable $usuario recoge la creación del objeto de conexión y utiliza el método consulta() para
recuperar el nombre de los usuarios de nuestra web. Para extraer todos los datos nos encontramos con un bucle que
va recuperando un array por registro, almacenándolo en $fila. Utilizando foreach podemos extraer todas las
columnas de la fila indicada. El resultado del script es el siguiente:
id: 1
nombre: Luis Miguel
apellidos: Cabezas Granado
cuenta: 0
id: 2
nombre: Francisco José
apellidos: González Lozano
cuenta: 0
id: 3
nombre: María Fernanda
apellidos: Jaramillo Polo
cuenta: 0
11.5. Manipulación de datos
Seleccionar datos de una base de datos es sólo el principio; la potencia de SQL nos permite también insertar,
actualizar y borrar filas de una tabla.
Con el objeto que hemos creado es muy sencillo hacer consultas del tipo INSERT, UPDATE o DELETE,
llamando al método consulta().
11.5.1. Insertar una fila
Para insertar una fila con nuestro objeto, tendremos que definir la consulta y ejecutar el método consulta().
<?php
require_once "[Link]";
$servidor = "localhost";
$usuario = "root";
$pass = "";
$baseDatos = "compras";
$insertar = "INSERT INTO usuarios(nombre, apellidos) VALUES('Sandra', 'Villena
González')";
$usuario = new ServidorBaseDatos($servidor, $usuario, $pass, $baseDatos);
$usuario->consulta($insertar);
?>
4
Curso PHP Básico Escuela de Administración Pública
11.5.2. Actualizar una fila
Antes de actualizar una fila, necesitas identificar la fila o filas de la tabla que quieres cambiar. En este ejemplo, se
ha utilizado una sentencia SELECT para averiguar primero el valor id de Luis Miguel y después proceder a
cambiar su cuenta bancaria.
<?php
require_once "[Link]";
$servidor = "localhost";
$usuario = "root";
$pass = "";
$baseDatos = "compras";
$consulta = "SELECT id FROM usuarios WHERE nombre = 'Luis Miguel'";
$usuario = new ServidorBaseDatos($servidor, $usuario, $pass, $baseDatos);
$usuario->consulta($consulta);
$fila = $usuario->extraerRegistro();
$idUsuario = $fila["id"] ;
$actualizar = "UPDATE usuarios SET cuenta = 9999 WHERE id = '$idUsuario'";
$usuario->consulta($actualizar);
?>
En un caso práctico, UPDATE puede utilizarse para modificar los datos introducidos en un formulario web.
11.5.3. Borrar una fila
Para borrar una fila puedes seguir el mismo camino que se ha utilizado antes para actualizar. Primero averigua el
registro que quieres eliminar y después ejecuta la consulta con la sentencia DELETE.
<?php
require_once "[Link]";
$servidor = "localhost";
$usuario = "root";
$pass = "";
$baseDatos = "compras";
$consulta = "SELECT id FROM usuarios WHERE nombre = 'Sandra'";
$usuario = new ServidorBaseDatos($servidor, $usuario, $pass, $baseDatos);
$usuario->consulta($consulta);
$fila = $usuario->extraerRegistro();
$idUsuario = $fila["id"];
$borrar = "DELETE FROM usuarios WHERE id = '$idUsuario'";
$usuario->consulta($borrar);
?>
11.6. Contar filas
A menudo es útil conocer el número de filas devueltas por una consulta antes de hacer cualquier cosa con el
resultado. Puedes averiguar el número de filas mediante el uso de alguna función de PHP o la utilización de
MySQL para obtener el número de registros.
11.6.1. Contar filas con PHP
La función mysqli_num_rows() devuelve el número de filas seleccionadas. Su uso puede ampliar el objeto de
bases de datos:
public function numeroFilas(){
return mysqli_num_rows($this->resultado);
}
Además de esta función tenemos mysqli_num_fields(), que devuelve el número de campos de una tabla; es
necesaria cuando hacemos una consulta de datos y no sabemos cuántas columnas hemos seleccionado.
11.6.2. Contar filas con MySQL
Para obtener el número de filas de un resultado podemos utilizar una consulta de SQL con la sentencia
count(*). Esto requiere hacer dos consultas, una para obtener el número de filas y otra para obtener el resultado.
5
Curso PHP Básico Escuela de Administración Pública
Utilicemos el objeto para realizar la operación:
<?php
require_once "[Link]";
$servidor = "localhost";
$usuario = "root";
$pass = "";
$baseDatos = "compras";
$usuario = new ServidorBaseDatos($servidor, $usuario, $pass, $baseDatos);
$consulta = "select count(*) as numero_filas from usuarios";
$usuario->consulta($consulta);
$fila = $usuario->extraerRegistro();
$numeroFilas = $fila["numero_filas"];
$consulta = "select * from usuarios";
$usuario->consulta($consulta);
echo "El número de filas es: $numeroFilas<br>";
while($fila = $usuario->extraerRegistro()){
foreach($fila as $indice => $valor){
echo "$indice: $valor<br>";
}
echo "<br>";
}
?>
La primera sentencia SELECT cuenta el número de filas y al resultado le da el nombre numero_filas. Para
acceder al número se hace como siempre, leyendo el resultado del array $fila["numero_filas"].
11.7. Contar filas afectadas
Es posible que sea necesario saber cuántas filas han sido afectadas después de añadir, actualizar o borrar algunas
filas. La función mysqli_affected_ rows() devuelve el número de registros afectados después de un cambio
en las filas de una tabla. Actualizando nuestra clase, tenemos:
public function filasAfectadas(){
return mysqli_affected_rows($this->descriptor);
}
11.8. Último número insertado
Cuando utilices campos auto numéricos en una tabla e insertes un nuevo registro, será útil conocer el número de
la última fila insertada. Para obtener este número tan sólo tienes que utilizar la función mysqli_insert_id().
Se puede utilizar de la siguiente forma:
public function ultimaFila(){
return mysqli_insert_id($this->descriptor);
}
11.9. PDO (PHP Data Object)
PDO es una capa de abstracción que actúa sobre las llamadas a bajo nivel de consultas al gestor de bases de datos.
Se compone de tres clases:
1. PDO, que se encarga de las conexiones.
2. PDOStatement, que envuelve consultas y resultados.
3. PDOException, su tipo nativo de excepciones.
En su forma más básica, usar PDO puede ser exactamente igual que usar cualquiera de los otros drivers existentes:
simplemente iniciamos una conexión, ejecutamos la consulta y usamos los resultados.
Para los ejemplos siguientes crea un archivo llamado [Link] con los datos de conexión al servidor:
<?php
$servidor = "localhost";
6
Curso PHP Básico Escuela de Administración Pública
$usuario = "usuario";
$pass = "secreto";
$baseDatos = "compras";
?>
A continuación crea el archivo [Link] con el siguiente contenido:
<!DOCTYPE html>
<html>
<head>
<title>Ejemplo 1 con PDO</title>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link href = "/css/[Link]" rel = "stylesheet">
<script src = "/js/[Link]" ></script>
<script src = "/js/[Link]"></script>
</head>
<body>
<div class="container">
<h1>Ejemplo 1 con PDO</h1>
<div class="col-md-12 well">
<?php
require_once "[Link]";
$baseDatosPDO = new PDO("mysql:host=$servidor;dbname=$baseDatos;
charset=utf8",$usuario,$pass);
$resultado = $baseDatosPDO->query("select * from usuarios");
foreach($resultado as $row){
echo $row['nombre']." ".$row['apellidos'].'<br>';
}
?>
</div>
</div>
</body>
</html>
La conexión se crea pasando un DSN (Data Source Name) o Nombre de Fuente de Datos, que no es más que un
string que indica el tipo de base de datos, su dirección y otros detalles necesarios para su conexión.
El método query() es muy parecido al método equivalente en mysqli. Lo realmente interesante es el objeto
$resultado. Como implementa la interfaz Iterator, este objeto puede ser pasado al bucle foreach para
extraer los valores de cada fila del resultado.
Si PHP no es capaz de conectar con la base de datos, se lanza una excepción del tipo PDOException. Para
evitar este tipo de errores se puede capturar esta excepción dentro de un bloque try/catch.
<?php
try{
require_once "[Link]";
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos;
charset=utf8", $usuario, $pass);
}catch(PDOException $e){
echo "Hubo algún error al intentar la conexión con MySQL";
echo print_r($e);
}
?>
El código anterior capturará el error en caso de fallo en la conexión y mostrará más información acerca de ese
error. Puedes probarlo cambiando alguna variable de la configuración y así forzar el fallo.
11.9.1. Seleccionar datos con PDO
Una vez creado el objeto PDO, podemos obtener datos a través de un objeto del tipo PDOStatement. Éste
representa nuestra consulta y nos permite navegar a través de las filas encontradas.
7
Curso PHP Básico Escuela de Administración Pública
<?php
require_once "[Link]";
$baseDatosPDO = new PDO ("mysql:host=$servidor; dbname=$baseDatos;
charset=utf8", $usuario, $pass);
$resultado = $baseDatosPDO->query("select * from usuarios");
while($fila = $resultado->fetch()){
echo $fila['nombre']." ".$fila['apellidos'].'<br>';
}
?>
En este caso hemos utilizado el método fetch() para extraer los datos. Hay varias formas de extraer los datos
con este método. El objeto PDOStatement se utiliza para recuperar la información de una consulta y se convierte
en un dataset (un conjunto de datos). Cada vez que llamamos a fetch() obtenemos una nueva fila. También es
posible llamar al método fetchAll() para recuperar todos los datos a la vez.
<?php
require_once "[Link]";
$baseDatosPDO = new PDO ("mysql:host=$servidor; dbname=$baseDatos;
charset=utf8", $usuario, $pass);
$resultado = $baseDatosPDO->query("select * from usuarios");
$filas = $resultado->fetchAll();
foreach($filas as $fila){
echo $fila['nombre']." ".$fila['apellidos'].'<br>';
}
?>
Ambos métodos aceptan un argumento que permite definir la forma de extraer las filas:
• PDO::FETCH_ASSOC: Devuelve un array cuyas claves son los nombres de las columnas devueltas.
• PDO::FETCH_NUM: También devuelve un array, pero esta vez las claves serán numéricas.
• PDO::FETCH_BOTH: (es el valor por defecto). Es una combinación de las dos primeras.
• PDO::FETCH_CLASS: Devuelve un objeto. Los valores de sus propiedades serán las columnas devueltas
de la consulta.
Para ver cómo funciona se puede ver el siguiente ejemplo:
<pre>
<?php
require_once "[Link]";
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos; charset=utf8",
$usuario, $pass);
$resultado = $baseDatosPDO->query("select * from usuarios");
while ($fila = $resultado->fetch(PDO::FETCH_BOTH)){
print_r($fila);
}
?>
</pre>
Como resultado obtendremos todas las filas de la tabla usuarios y, por cada fila, dos formas de acceder a los datos:
mediante un índice numérico o mediante el nombre de la columna obtenida.
11.9.2. Parámetros y sentencias preparadas
MySQL soporta el uso de sentencias preparadas, que son sentencias que se ejecutan repetidamente y hacen un
uso muy eficiente del gestor de bases de datos. La ejecución de sentencias preparadas consiste en dos etapas: la
preparación y la ejecución. En la etapa de preparación se envía una plantilla de sentencia al servidor de bases de
datos. El servidor realiza una comprobación de sintaxis e inicializa los recursos internos del servidor para su uso
posterior.
<pre>
<?php
require_once "[Link]";
8
Curso PHP Básico Escuela de Administración Pública
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos; charset=utf8",
$usuario, $pass);
$sql = "select id, nombre, apellidos from usuarios where id = :id";
$sentencia = $baseDatosPDO->prepare($sql);
$sentencia->execute(array("id" => 2));
while($fila = $sentencia->fetch(PDO::FETCH_BOTH)){
print_r($fila).'<br>';
}
?>
</pre>
La variable $sql contiene la consulta que queremos hacer en la base de datos. La parte que cambiará de esa
consulta está representada con el símbolo de los dos puntos (:). Esta variable se pasa como parámetro al método
prepare() y todo está listo para la ejecución.
El siguiente paso es ejecutar la sentencia con el método execute(). Éste método recibe un array con los valores
definidos en la sentencia preparada y la ejecuta almacenando los datos en el objeto PDOStatement.
Las consultas preparadas definen perfectamente qué partes de la consulta son lenguaje de la base de datos y qué
partes son variables. También previenen de ataques del tipo SQL Injection porque controlan todos los caracteres
que se lanzan al gestor de bases de datos.
11.9.3. Enlazar valores y variables a sentencias preparadas
Una vez MySQL ha preparado una consulta, sólo tendremos que preocuparnos por añadir nuevos valores a la
consulta para obtener nuevos resultados. Mira el ejemplo siguiente:
<pre><?php
require_once "[Link]";
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos; charset=utf8",
$usuario, $pass);
$sql = "select id, nombre, apellidos from usuarios where id = :id";
$sentencia = $baseDatosPDO->prepare($sql);
$sentencia->bindValue(":id", 1);
$sentencia->execute();
$luis = $sentencia->fetch(PDO::FETCH_BOTH);
$sentencia->bindValue(":id", 2);
$sentencia->execute();
$paco = $sentencia->fetch(PDO::FETCH_BOTH);
print_r($luis);
print_r($paco);
?></pre>
En este caso, el método bindValue() es el encargado de añadir las variables a la sentencia. Tras esto podemos
ejecutarla con el valor añadido y recibir los datos en una variable. En el ejemplo, las variables $luis y $paco
reciben datos distintos tras la ejecución de la misma sentencia.
11.9.4. Insertar filas
La inserción de datos y la actualización no distan demasiado de la forma de trabajar anteriormente. Se prepara la
sentencia, se combinan los datos variables y se ejecuta.
<?php
require_once "[Link]";
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos; charset=utf8",
$usuario, $pass);
$sql = "insert into usuarios(nombre, apellidos, cuenta) values(:nombre,
:apellidos, :cuenta)";
$sentencia = $baseDatosPDO->prepare($sql);
$sentencia->bindValue(":nombre", 'Gabriel');
$sentencia->bindValue(":apellidos", 'Villena');
$sentencia->bindValue(":cuenta", 3342);
$sentencia->execute();
9
Curso PHP Básico Escuela de Administración Pública
echo "El último id es ".$baseDatosPDO->lastInsertId();
?>
Este ejemplo hace uso de bindValue() para añadir varias variables a la sentencia. Tras la ejecución MySQL
nos devuelve el último id insertado en la base de datos haciendo uso del método lastInsertId().
11.9.5. Número de filas insertadas, actualizadas o borradas
Cuando realizamos una consulta del tipo INSERT, UPDATE o DELETE, podemos saber cuántas filas de la
base de datos han sido modificadas. Para ello se utiliza el método rowCount(). El siguiente ejemplo borra las filas
cuyo id es mayor que 3 y obtiene el número de filas borradas.
<?php
require_once "[Link]";
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos; charset=utf8",
$usuario, $pass);
$sql = "delete from usuarios where id > :id";
$sentencia = $baseDatosPDO->prepare($sql);
$sentencia->bindValue(":id", 3);
$sentencia->execute();
echo "Número de filas borradas: ".$sentencia->rowCount();
?>
11.9.6. Transacciones
Una transacción es una colección de consultas que deben ser ejecutadas en grupo. La peculiaridad es que se está
obligado a ejecutar el conjunto completo de sentencias o no ejecutar ninguna. No todas las bases de datos pueden
utilizar transacciones y, en MySQL, no todos los tipos de tabla.
Nota: Si la tabla o la base de datos no permite transacciones, puede obtener resultados
inesperados en las consultas.
Para usar transacciones no necesitamos hacer muchos cambios en nuestro código. Si tenemos un conjunto de
sentencias que deben ejecutarse en conjunto sólo necesitamos:
1. Inicializar la transacción llamando al método beginTransaction() antes de ejecutar cualquier
consulta.
2. Llamar al método commit() cuando todas las sentencias se hayan ejecutado correctamente.
3. Cancelar la transacción si algo ha fallado con el método rollBack(). Esto deshará aquellas consultas que
se hayan ejecutado hasta el momento de obtener el error.
Veamos un ejemplo:
<!DOCTYPE html>
<html>
<head>
<title>Transacciones con PDO</title>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link href = "/css/[Link]" rel = "stylesheet">
<script src = "/js/[Link]" ></script>
<script src = "/js/[Link]"></script>
</head>
<body>
<div class="container">
<h1>Ejemplo con PDO</h1>
<div class="col-md-12 well">
<?php
require_once "[Link]";
try{
10
Curso PHP Básico Escuela de Administración Pública
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos;
charset=utf8", $usuario, $pass);
}catch(PDOException $e){
echo "Imposible conectar con la base de datos";
exit;
}
try {
$baseDatosPDO->beginTransaction();
$sql = "update usuarios set cuenta = 0 where id = :id";
$sentencia = $baseDatosPDO->prepare($sql);
$sentencia->bindValue(":id", 1);
$sentencia->execute();
$sentencia->bindValue (":id", 2);
$sentencia->execute();
$sentencia->bindValue (":id", 3);
$sentencia->execute();
$baseDatosPDO->commit();
echo "Filas actualizadas";
} catch(PDOException $e){
$baseDatosPDO->rollBack();
echo "Hubo algún error en la transacción ".$e->getMessage();
}
?>
</div>
</div>
</body>
</html>
Es posible utilizar rollBack()desde cualquier sitio.
11.9.7. Procedimientos almacenados desde PDO
Algunas bases de datos permiten el uso de procedimientos almacenados. Éstos son similares a las funciones, pero
almacenados a nivel de base de datos. Pueden tomar parámetros cuando son llamados, formar parte de sentencias
preparadas.
Veamos un procedimiento almacenado que devuelve todos los usuarios ordenados alfabéticamente por apellidos y
nombre.
delimiter $$
CREATE PROCEDURE obtener_usuarios()
BEGIN
SELECT id, nombre, apellidos
FROM usuarios
ORDER BY apellidos, nombre;
END $$
delimiter ;
Aunque es una construcción que excede el contenido de este libro, puedes ver que es muy sencillo entender la
esencia del procedimiento. Simplemente lo que hace es seleccionar todos los usuarios y le da el nombre de
obtener_usuarios(). Puedes añadir a MySQL el procedimiento almacenado del ejemplo ejecutándolo desde
phpMyAdmin.
Los procedimientos almacenados pueden ser llamados desde el código PHP y desde PDO como puedes ver en el
ejemplo siguiente:
<pre>
<?php
require_once "[Link]";
$baseDatosPDO = new PDO("mysql:host=$servidor; dbname=$baseDatos; charset=utf8",
$usuario, $pass);
$resultado = $baseDatosPDO->query('call obtener_usuarios()');
11
Curso PHP Básico Escuela de Administración Pública
$filas = $resultado->fetchAll();
print_r($filas);
?>
</pre>
Para ejecutar un procedimiento sólo tienes que hacer una llamada en el método query() con la palabra call
seguido del nombre del procedimiento. Una vez hecha la consulta, se obtienen las filas y se muestran en pantalla.
11.10. Taller 7: Agenda de contactos con MySQL
Proyecto final de curso: Adapta la agenda de contactos para que utilice una base de datos MySQL como origen de
datos.
12