Trabajar con bases de datos en PHP
En este documento · 13 secciones
- 1. Acceso a bases de datos desde PHP
- Nociones básicas de objetos en PHP
- 2. MySQL
- 2.1 Instalación y configuración
- 2.2 Herramientas de administración
- 2.3 Ampliación: el lenguaje SQL desde cero
- 3. Utilización de bases de datos MySQL en PHP
- 3.1 Extensión MySQLi
- 3.2 PHP Data Objects (PDO)
- 4. Errores y manejo de excepciones
- 4.1 Excepciones
- 4.2 Ampliación: aplicación CRUD completa con PDO
- Ideas clave
Una aplicación web casi nunca guarda sus datos en ficheros sueltos: los guarda en un sistema gestor de bases de datos (SGBD) y los consulta o modifica desde el código del servidor. Esta unidad explica cómo hacerlo desde PHP con el gestor más usado junto a él, MySQL.
La unidad se divide en cuatro partes:
- Acceso a bases de datos desde PHP: extensiones nativas frente a PDO, y lo mínimo de objetos que hace falta para usarlas.
- MySQL: instalación, configuración y herramientas de administración (
mysql,mysqladmin, phpMyAdmin). Se añade una introducción al lenguaje SQL desde cero (apartado 2.3), porque todo lo que sigue envía sentencias SQL al servidor. - Utilización de MySQL en PHP: las dos extensiones recomendadas, MySQLi y PDO, con conexiones, consultas, transacciones, recorrido de resultados y consultas preparadas.
- Errores y excepciones: niveles de error de PHP,
try/catchy excepciones de PDO. Termina con una aplicación completa de altas, bajas, modificaciones y consultas con PDO (apartado 4.2).
Sobre la vigencia del temario. Parte del temario describe el comportamiento de versiones antiguas de MySQL y PHP (motor por defecto, modo de errores de PDO y de MySQLi, valor por defecto de
error_reporting). Se expone tal como lo recoge; lo que ha cambiado se indica en recuadros Contexto actual.
1. Acceso a bases de datos desde PHP
Una de las aplicaciones más frecuentes de PHP es generar una interfaz web para consultar y gestionar la información de una base de datos: mostrar en una página datos extraídos de ella, o enviar al gestor sentencias para que inserte, actualice o elimine registros.
PHP soporta más de 15 sistemas gestores: SQLite, Oracle, SQL Server, PostgreSQL, IBM DB2, MySQL, etc. Hay dos maneras de comunicarse con ellos:
| Extensión nativa | PDO | |
|---|---|---|
| Qué es | Una extensión específica para un gestor concreto (por ejemplo, MySQLi para MySQL) | Una extensión que accede de forma común a distintos gestores |
| Desde cuándo | Era la forma habitual hasta PHP 5 | Se introdujo en PHP 5 |
| Sintaxis | Funciones y objetos distintos para cada gestor | La misma, aunque cambie el gestor |
| Ventajas | Más potencia (acceso a funciones específicas del gestor) y, a veces, más velocidad | Si se cambia de gestor, el código apenas cambia |
MySQL es un gestor de bases de datos relacionales de código abierto, con licencia GNU GPL, y el más empleado con PHP: es la “M” de AMP y de XAMPP. La unidad explica cómo acceder a él con las dos opciones: PDO y la extensión nativa MySQLi.
Nociones básicas de objetos en PHP
Las dos extensiones se usan a través de objetos. La programación orientada a objetos en PHP se estudia en una unidad posterior; aquí basta con dos operaciones:
- Crear un objeto instanciando una clase, con
new. - Acceder a sus miembros (métodos y propiedades) con el operador flecha
->.
$a = new A(); // crea un objeto de la clase A
$a->fecha(); // llama al método fecha() del objeto
echo $a->nombre; // lee la propiedad nombre (sin $ delante del nombre de la propiedad)Analogía con Java:
newfunciona igual. Lo que en Java se escribea.fecha(), en PHP se escribe$a->fecha(). Las constantes de una clase se leen con::, como los miembros estáticos de Java:PDO::FETCH_ASSOCequivale a algo comoPDO.FETCH_ASSOC.
2. MySQL
MySQL es un sistema gestor de bases de datos (SGBD) relacionales. Es de código abierto (GNU GPL), aunque también ofrece una licencia comercial para quien quiera desarrollar aplicaciones de código propietario. Desde la versión 5.1 hay varios productos: uno libre (Community Edition) y otros comerciales (Standard Edition, Enterprise Edition).
Incorpora varios motores de almacenamiento, cada uno con características propias; al crear una tabla se elige el que convenga. Los dos que hay que conocer:
| MyISAM | InnoDB | |
|---|---|---|
| Por defecto | Sí: es el que se utiliza por defecto | No |
| Velocidad | Es más rápido | Un poco más lento |
| Transacciones | No | Soporta transacciones (tablas transaccionales) |
| Integridad referencial | No | Soporta integridad referencial |
Por eso, de las cuatro características, las que no son ventajas del motor de almacenamiento InnoDB sobre MyISAM son “es el que se utiliza por defecto” y “es más rápido”: las dos son de MyISAM.
Contexto actual: desde MySQL 5.5 (2010) el motor por defecto es InnoDB, y MariaDB hace lo mismo. MyISAM ya casi no se usa.
MySQL se usa en multitud de aplicaciones web, casi siempre junto a PHP y Apache. Gestiona, consulta y modifica la información con SQL; soporta la mayor parte de ANSI SQL 99 y añade extensiones propias.
MariaDB es un gestor derivado de MySQL, también GPL, desarrollado por la comunidad de MySQL antes de que Oracle comprara el proyecto. Es el que trae XAMPP. Salvo ligeros cambios, los dos son altamente compatibles y a efectos del módulo da igual usar uno u otro.
Siglas que conviene no confundir. PDO no es un motor de almacenamiento: es una extensión de PHP que permite acceder a varios gestores de bases de datos. Los motores son MyISAM, InnoDB y sus equivalentes en MariaDB.
2.1 Instalación y configuración
En Linux, MySQL se reparte en dos paquetes que se instalan por separado según lo que haga falta:
- mysql-server: el servidor en sí. Gestiona las bases de datos y acepta conexiones desde el propio equipo o desde la red.
- mysql-client: los programas cliente, necesarios para conectarse a un servidor MySQL. Solo hacen falta en los equipos que se vayan a conectar.
Aunque son paquetes distintos, el servidor depende del cliente: al instalar el paquete correspondiente al servidor MySQL en un sistema Linux, se instalan también los programas cliente que permiten conectarse con el mismo. En cambio, en un equipo que solo tenga que conectarse a un servidor remoto basta con instalar el paquete cliente.
El servicio se gestiona como cualquier otro del sistema:
| Orden | Qué hace |
|---|---|
sudo systemctl start mysql |
Inicia el servicio |
sudo systemctl stop mysql |
Lo detiene |
sudo systemctl restart mysql |
Lo reinicia |
sudo systemctl status mysql |
Informa de su estado |
Si se instaló LAMP en Ubuntu, el usuario root de MySQL/MariaDB no tiene contraseña y usa el plugin de autenticación auth_socket: solo puede entrar un usuario de Ubuntu con permisos de administrador, con sudo mysql -u root. Se recomienda no cambiarlo y, para cada proyecto, crear una base de datos y un usuario propio:
-- 1. En la terminal de Linux: sudo mysql -u root
CREATE DATABASE biblioteca; -- 2. crea la base de datos
CREATE USER bibliotecario@'localhost' IDENTIFIED BY 'secreto'; -- 3. crea el usuario con su contraseña
GRANT ALL ON biblioteca.* TO bibliotecario@'localhost'; -- 4. le da todos los permisos sobre esa BD
QUIT; -- 5. vuelve a la terminal
-- 6. Comprobación, en la terminal: mysql -u bibliotecario -p bibliotecabiblioteca.*significa “todas las tablas de la base de datosbiblioteca”;*.*sería todas las tablas de todas las bases de datos.'localhost'limita el usuario a conexiones desde el propio equipo.
Después, phpMyAdmin o cualquier otro programa puede administrar la base de datos con las credenciales de ese usuario. En XAMPP para Windows, phpMyAdmin se abre desde el panel de control (botón Admin junto a MySQL) y entra directamente como root.
Datos de configuración que hay que conocer:
- Puerto: el servidor escucha por defecto en el TCP 3306. Hay que tenerlo en cuenta para abrir el cortafuegos en configuraciones en red.
- Fichero de configuración:
my.cnf, en/etc/mysql. No se configura enhttpd.conf(Apache) ni enphp.ini(PHP). En Windows se llamamy.ini. - Se divide en secciones, cada una para un módulo:
[client]: parámetros que afectan a los clientes que se conectan al servidor.[mysqld]: opciones de ejecución del servidor.
- Parámetros destacados:
port(puerto TCP de escucha),user(usuario del sistema que ejecuta el servidor) ydatadir(directorio donde se guardan las bases de datos).
2.2 Herramientas de administración
Hay muchas herramientas para conectarse a un servidor MySQL y administrarlo: de línea de comandos o gráficas (web o nativas del sistema operativo), incluidas con el servidor o instaladas aparte, de propósito concreto o general.
Con el servidor se incluyen tres herramientas de línea de comandos:
mysql: se conecta a un servidor para ejecutar sentencias.mysqladmin: cliente específico para tareas de administración.mysqlshow: muestra información sobre bases de datos y tablas.
Comparten las opciones de conexión:
| Opción larga | Abreviada | Significado | Si se omite |
|---|---|---|---|
--user=nombre |
-u nombre |
Usuario con permisos para conectarse | El usuario actual del sistema operativo |
--password=clave |
-pclave |
Contraseña. En la forma corta va pegada a la p, sin espacio |
Si hace falta, se pide al conectar |
--host=equipo |
-h equipo |
Equipo servidor | localhost |
Ejemplos:
sudo mysql -u root: entra comorootcon la configuración recomendada de Ubuntu.mysql -u juan -p proyecto: entra comojuan, pide la contraseña y selecciona directamente la base de datosproyecto.- En Windows con XAMPP, el ejecutable está en
c:\xampp\mysql\bin\; desde una consola abierta ahí bastamysql -u root.
Error frecuente:
-p proyectono es “la contraseña es proyecto”: con espacio,proyectoes el nombre de la base de datos y la contraseña se pide aparte. Y se recomienda no escribir nunca la contraseña en la línea de comandos, porque quedaría guardada en el historial del sistema.
Dos herramientas independientes muy usadas:
- MySQL Workbench: herramienta genérica con interfaz gráfica nativa para administrar el servidor y sus bases de datos. La desarrollan los creadores de MySQL; tiene una edición GPL.
- phpMyAdmin: aplicación web escrita en PHP (GPL) para administrar las bases de datos y la información del servidor.
| Herramienta | Tipo de interfaz |
|---|---|
| MySQL Workbench | Nativo |
| mysql | Línea de comandos |
| phpMyAdmin | Web |
| mysqladmin | Línea de comandos (administración) |
Error frecuente:
myadminno es una herramienta de administración de MySQL. Existenmysql,mysqladmin,mysqlshow, phpMyAdmin y MySQL Workbench; “myadmin” es un nombre inventado parecido.
Ojo con el término: el temario dice “un interface” en masculino. Es el mismo concepto que “una interfaz”.
2.2.1 mysql y mysqladmin
mysql se usa normalmente en modo interactivo: tras conectarse, presenta una línea de órdenes donde se escriben sentencias SQL, que terminan en ;, y algunos comandos especiales:
| Comando | Qué hace |
|---|---|
connect |
Establece una conexión con un servidor |
use |
Selecciona una base de datos: use biblioteca; |
exit o quit |
Termina la sesión |
help |
Muestra la lista de comandos |
También ejecuta todas las sentencias de un fichero de procesamiento por lotes (texto plano con instrucciones, normalmente .sql), redirigiéndolo a la entrada:
mysql -u bibliotecario -p biblioteca < crearTablas.sql # ejecuta el fichero sobre la BD biblioteca
sudo mysql -u root < biblioteca.sql # el fichero crea él mismo la BD, el usuario y los permisosSi todo va bien, vuelve a la consola sin ningún mensaje; si algo falla, muestra el error.
Para saber si existe o no un registro en una tabla se usa mysql, porque permite ejecutar consultas sobre el contenido. mysqladmin hace tareas administrativas, pero no consulta datos.
Emojis y utf8mb4. El antiguo utf8 de MySQL usa hasta 3 bytes por carácter y no admite emojis. Desde MySQL 5.5.3 existe utf8mb4, hasta 4 bytes por carácter. Se elige al crear la base de datos:
CREATE DATABASE mi_base_de_datos CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci;La base de datos proyecto. Los ejemplos del temario usan una base de datos llamada proyecto, con usuario gestor y contraseña secreto, que se crea con un fichero proyecto.sql y se carga con sudo mysql -u root < proyecto.sql. Tiene cuatro tablas:
| Tabla | Columnas | Relación |
|---|---|---|
productos |
id, nombre, nombre_corto, descripcion, pvp, familia |
familia apunta a familias.cod |
tiendas |
id, nombre, tlf |
|
familias |
cod, nombre |
|
stocks |
producto, tienda, unidades |
producto apunta a productos.id; tienda, a tiendas.id |
Después se cargan los datos (datosProyecto.sql) desde phpMyAdmin (apartado 2.2.2).
mysqladmin es no interactiva: la tarea se indica como parámetro en la línea de comandos. Permite:
- Crear y eliminar bases de datos.
- Mostrar la configuración y el estado del servidor.
- Cambiar contraseñas.
- Detener el servidor.
mysqladmin --help # lista los comandos disponibles
sudo mysqladmin status # estado actual del servidor
sudo mysqladmin version # versión instalada
sudo mysqladmin -u root create miBase # crea la base de datos miBase (necesita sudo y root)2.2.2 phpMyAdmin
Al contrario que las anteriores, phpMyAdmin no se instala con el servidor MySQL. En Ubuntu hay dos formas:
- Con el gestor de paquetes:
sudo apt install phpmyadmin. Pregunta el servidor web (se elige apache2) y crea una base de datos propia. Se accede enhttp://localhost/phpmyadmin/. - Descargando el paquete de phpmyadmin.net y descomprimiéndolo en
/var/www/html(la raíz de Apache en Ubuntu), en una carpeta renombradaphpmyadmin.
Para entrar hacen falta usuario y contraseña de MySQL: con gestor/secreto se gestiona solo la base de datos proyecto. Para entrar con todos los permisos en Ubuntu, sin tocar la autenticación de root, se crea un usuario administrador:
-- en la terminal: sudo mysql -u root
CREATE USER admin@'localhost' IDENTIFIED BY 'secreto';
GRANT ALL ON *.* TO admin@'localhost' WITH GRANT OPTION; -- todos los permisos, y además puede concederlos
FLUSH PRIVILEGES; -- recarga la tabla de permisosLa interfaz tiene un panel de navegación a la izquierda con las bases de datos y un panel principal con un menú superior. Al seleccionar una base de datos, ese menú permite:
- Ver y modificar la estructura.
- Ejecutar sentencias SQL.
- Buscar información en toda la base de datos o en parte.
- Generar una consulta con un asistente (pestaña Generar una consulta).
- Exportar e importar estructura y datos (Exportar genera un
.sqlcon las instrucciones para recrear tablas y datos; Importar ejecuta un.sql). - Diseñar las relaciones entre tablas (Diseñador).
- Otras operaciones, como copiar la base de datos.
Con una tabla seleccionada se hacen operaciones similares a nivel de tabla (examinar, estructura, buscar, insertar, vaciar, eliminar).
Cargar un fichero de datos: se selecciona la base de datos en el panel izquierdo, pestaña Importar, Examinar para elegir el .sql, Continuar, y se comprueba en el mensaje final que no ha habido errores.
2.3 Ampliación: el lenguaje SQL desde cero
PHP no consulta la base de datos por sí mismo: le envía al servidor MySQL una sentencia SQL como cadena de texto, y el servidor la ejecuta. Por eso hay que saber escribir esas sentencias. Este apartado cubre las cuatro que usa la unidad: SELECT, INSERT, UPDATE y DELETE.
2.3.1 Tablas, filas y columnas
Una base de datos relacional guarda la información en tablas. Cada fila (o registro) es un elemento; cada columna (o campo) es un dato de ese elemento. Ejemplo con la base de datos biblioteca que se usa en toda la unidad:
Tabla generos:
| cod | nombre |
|---|---|
| NOV | Novela |
| POE | Poesía |
| ENS | Ensayo |
Tabla libros:
| id | titulo | autor | paginas | genero | sinopsis |
|---|---|---|---|---|---|
| 1 | La Regenta | Leopoldo Alas | 720 | NOV | Vetusta, una ciudad de provincias… |
| 2 | Campos de Castilla | Antonio Machado | 210 | POE | NULL |
| 3 | El árbol de la ciencia | Pío Baroja | 300 | NOV | NULL |
| 4 | Meditaciones del Quijote | José Ortega y Gasset | 180 | ENS | NULL |
- Clave primaria: columna que identifica cada fila sin repetirse (
idenlibros,codengeneros). - Clave ajena: columna que guarda la clave primaria de otra tabla (
libros.generoguarda ungeneros.cod). Con InnoDB, el gestor impide que apunte a un género que no existe y, salvo que se configure otra cosa, impide borrar un género que tiene libros. NULL: ausencia de valor. No es una cadena vacía ni un cero.AUTO_INCREMENT: el gestor asigna solo el siguiente número a la clave primaria al insertar; por eso en las altas no se indica elid.
La tabla se crea así (no se usa en la unidad, pero permite leer ficheros como proyecto.sql):
CREATE TABLE generos (
cod VARCHAR(6) PRIMARY KEY, -- texto de hasta 6 caracteres; clave primaria
nombre VARCHAR(50) NOT NULL -- obligatorio
) ENGINE = InnoDB;
CREATE TABLE libros (
id INT AUTO_INCREMENT PRIMARY KEY, -- entero numerado por el gestor
titulo VARCHAR(150) NOT NULL,
autor VARCHAR(100) NOT NULL,
paginas INT, -- puede quedar a NULL
genero VARCHAR(6) NOT NULL,
sinopsis TEXT, -- texto largo
FOREIGN KEY (genero) REFERENCES generos(cod) -- clave ajena
) ENGINE = InnoDB;Tipos habituales: INT (entero), DECIMAL(10,2) (número con 2 decimales exactos, el adecuado para precios), VARCHAR(n) (texto de hasta n caracteres), TEXT (texto largo), DATE (fecha).
Analogía con Java: una tabla es como una clase con solo atributos (
Libroconid,titulo…), y cada fila, un objeto de esa clase. La clave ajena es como un atributo que guarda la referencia a otro objeto, pero escrita como su identificador.
2.3.2 Reglas generales de escritura
- Cada sentencia termina en
;(en la herramientamysql; desde PHP se puede omitir). - Las palabras clave (
SELECT,FROM…) no distinguen mayúsculas; se escriben en mayúsculas por costumbre, para distinguirlas de los nombres de tablas y columnas. - Los textos y las fechas van entre comillas (
'Novela','2026-11-13'); los números, sin comillas y con punto decimal (19.95). - Comentario de una línea:
-- texto(con espacio tras los guiones).
Error frecuente: el SQL estándar delimita los textos con comillas simples. MySQL acepta también dobles, y el temario las usa (
VALUES ("TABLET", "Tablet PC")) porque así la cadena PHP puede ir entre comillas simples. Lo que no se puede es mezclar sin cuidado:'SELECT * FROM libros WHERE autor = 'Baroja''rompe la cadena PHP en la segunda comilla simple.
2.3.3 SELECT: consultar
SELECT columnas FROM tabla WHERE condición ORDER BY columna;Solo SELECT y FROM son obligatorias. El resultado es una tabla nueva (el conjunto de resultados), que no modifica nada.
SELECT * FROM libros; -- todas las columnas (*) de todas las filas
SELECT id, titulo FROM libros; -- solo dos columnas
SELECT titulo FROM libros WHERE genero = 'NOV'; -- La Regenta, El árbol de la ciencia
SELECT * FROM libros WHERE id = 3; -- una sola fila: la del id 3
SELECT titulo, paginas FROM libros WHERE paginas < 250; -- Campos de Castilla, Meditaciones…
SELECT id, titulo FROM libros ORDER BY titulo; -- ordenados alfabéticamente por título
SELECT titulo FROM libros ORDER BY paginas DESC; -- de más a menos páginasOperadores de la condición WHERE:
| Operador | Significado | Ejemplo |
|---|---|---|
= |
igual (uno solo, no ==) |
genero = 'POE' |
<> o != |
distinto | genero <> 'POE' |
<, >, <=, >= |
comparación | paginas >= 300 |
AND, OR, NOT |
combinan condiciones | genero = 'NOV' AND paginas > 500 |
LIKE |
patrón de texto: % = cualquier secuencia |
titulo LIKE '%Castilla%' |
IS NULL, IS NOT NULL |
comprueba la ausencia de valor | sinopsis IS NULL |
Error frecuente:
sinopsis = NULLno encuentra nada, porqueNULLno es igual a nada, ni siquiera a sí mismo. Se escribesinopsis IS NULL.
2.3.4 INSERT: añadir filas
INSERT INTO tabla (columna1, columna2, …) VALUES (valor1, valor2, …);Los valores van en el mismo orden que las columnas listadas.
INSERT INTO generos (cod, nombre) VALUES ('TEA', 'Teatro');
INSERT INTO libros (titulo, autor, paginas, genero)
VALUES ('Luces de bohemia', 'Ramón del Valle-Inclán', 160, 'TEA'); -- id lo pone AUTO_INCREMENT; sinopsis queda a NULLError frecuente: insertar una clave primaria que ya existe (
INSERT INTO generos … VALUES ('NOV', …)) da error de clave duplicada. Y en una clave ajena solo valen valores que existan en la otra tabla:genero = 'XYZ'da error de integridad referencial.
2.3.5 UPDATE: modificar filas
UPDATE tabla SET columna1 = valor1, columna2 = valor2 WHERE condición;UPDATE libros SET paginas = 712 WHERE id = 1; -- cambia un dato de una fila
UPDATE libros SET titulo = 'La Regenta (ed. crítica)', paginas = 900 WHERE id = 1; -- varias columnas
UPDATE libros SET sinopsis = 'Pendiente' WHERE sinopsis IS NULL; -- varias filas a la vez2.3.6 DELETE: borrar filas
DELETE FROM tabla WHERE condición;DELETE FROM libros WHERE id = 4; -- borra una fila
DELETE FROM libros WHERE paginas < 100; -- borra todas las que cumplan la condiciónError frecuente: sin
WHERE,UPDATEyDELETEafectan a todas las filas de la tabla.DELETE FROM libros;vacía la tabla entera yUPDATE libros SET paginas = 0;pone a cero todos los libros. No hay “¿está seguro?”.
Error frecuente: en
DELETEno se escriben columnas (DELETE * FROMes incorrecto): se borran filas enteras.
2.3.7 Consultas de selección y consultas de acción
| Consulta de selección | Consulta de acción | |
|---|---|---|
| Sentencias | SELECT |
INSERT, UPDATE, DELETE |
| Qué devuelve | Un conjunto de resultados (filas) | Nada, salvo el número de registros afectados |
| Modifica datos | No | Sí |
Esta distinción decide qué método se usa en PHP para ejecutar cada sentencia (apartados 3.1.2 y 3.2.2).
3. Utilización de bases de datos MySQL en PHP
Hay dos formas de comunicarse con una base de datos desde PHP: una extensión nativa, programada para un gestor concreto, o una extensión que soporte varios gestores.
Tradicionalmente se usaba la extensión nativa mysql. Se ha usado habitualmente para acceder a bases de datos MySQL, pero hoy en día su uso está desaconsejado: se mantenía solo para dar soporte a aplicaciones antiguas. Las dos extensiones más recomendables para acceder a MySQL desde PHP son MySQLi (nativa) y PDO.
Contexto actual: la extensión
mysql(funcionesmysql_connect,mysql_query…) se eliminó en PHP 7.0 (2015). Hoy ni siquiera existe.
Con cualquiera de las dos se puede:
- Establecer conexiones.
- Ejecutar sentencias SQL.
- Obtener los registros afectados o devueltos por una sentencia.
- Emplear transacciones.
- Ejecutar procedimientos almacenados.
- Gestionar los errores de conexión o de ejecución.
Por debajo, PDO, MySQLi (y la antigua mysql) usan un driver de bajo nivel para hablar con el servidor. Antes solo existía libmysql, no optimizado para PHP. Desde PHP 5.3 existe el driver nativo mysqlnd: un driver de bajo nivel para MySQL, que se puede usar tanto con la extensión MySQLi como con PDO, y sustituye al habitual libmysql.
Error frecuente:
libmysqlymysqlndson drivers, no extensiones. Las extensiones sonmysql, MySQLi y PDO.
| Capa | Opciones |
|---|---|
| Código PHP del programa | llama a una extensión |
| Extensión | mysql (obsoleta), MySQLi, PDO |
| Driver de bajo nivel | libmysql (antiguo), mysqlnd |
| Servidor | MySQL / MariaDB |
Cada capa solo habla con la de debajo:
flowchart TD
A["Código PHP del programa"] --> B{"Extensión"}
B --> B1["MySQLi"]
B --> B2["PDO"]
B -.->|"obsoleta"| B3["mysql"]
B1 --> C["Driver de bajo nivel<br/>mysqlnd (antes libmysql)"]
B2 --> C
B3 -.-> C
C --> D[("Servidor MySQL / MariaDB")]
3.1 Extensión MySQLi
MySQLi se desarrolló para aprovechar las versiones 4.1.3 y posteriores de MySQL y viene con PHP desde la versión 5. Ofrece una interfaz de programación dual: procedimental y orientada a objetos. Cada operación puede hacerse con un método de un objeto o con una función equivalente:
// Orientado a objetos: constructor y métodos/propiedades
$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
print $conexion->server_info; // versión del servidor
// Procedimental: funciones
$conexion = mysqli_connect('localhost', 'bibliotecario', 'secreto', 'biblioteca');
print mysqli_get_server_info($conexion);En los dos casos $conexion es un objeto; la forma orientada a objetos suele dar un código más corto y legible.
Mejoras respecto a la antigua extensión mysql:
- Interface orientado a objetos.
- Soporte para transacciones.
- Soporte para consultas preparadas.
- Mejores opciones de depuración y seguridad.
Error frecuente: “es una extensión nativa” no es una ventaja sobre
mysql, porque las dos son nativas. Y “permite utilizar excepciones” tampoco: MySQLi usa el sistema de errores clásico de PHP; las excepciones son propias de PDO (apartado 4.1).
Contexto actual: desde PHP 8.1, MySQLi lanza por defecto excepciones
mysqli_sql_exceptioncuando falla una conexión o una consulta.
La configuración de MySQLi se hace en php.ini, en la sección propia de la extensión (no hay un mysqli.conf, y httpd.conf y my.ini son de Apache y de MySQL):
| Directiva | Para qué sirve |
|---|---|
mysqli.allow_persistent |
Permite crear conexiones persistentes |
mysqli.default_port |
Puerto TCP por defecto para conectar |
mysqli.reconnect |
Reconectar automáticamente si se pierde la conexión |
mysqli.default_host |
Servidor por defecto |
mysqli.default_user |
Usuario por defecto |
mysqli.default_pw |
Contraseña por defecto |
3.1.1 Establecimiento de conexiones
Toda comunicación con el servidor se hace a través de una conexión, que se abre primero. Con MySQLi, abrirla es crear una instancia de la clase mysqli. El constructor admite seis parámetros, todos opcionales; lo habitual son los cuatro primeros:
- Nombre o IP del servidor.
- Usuario.
- Contraseña.
- Base de datos.
- Puerto.
- Socket o tubería con nombre (named pipe).
Para conectar con MySQLi se puede utilizar indistintamente el constructor o el método connect:
// 1. Con el constructor
$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
// 2. Creando primero el objeto y conectando después con connect
$conexion = new mysqli();
$conexion->connect('localhost', 'bibliotecario', 'secreto', 'biblioteca');
// 3. Con la interfaz procedimental
$conexion = mysqli_connect('localhost', 'bibliotecario', 'secreto', 'biblioteca');Hay que comprobar que la conexión se ha establecido. Para ello, la clase mysqli tiene dos propiedades (y dos funciones equivalentes):
| Propiedad | Función | Devuelve |
|---|---|---|
connect_errno |
mysqli_connect_errno() |
El número de error (0 si no hay error) |
connect_error |
mysqli_connect_error() |
El mensaje de error, o null si no hay error |
El mensaje del error se obtiene, por tanto, con la propiedad connect_error.
@$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
$error = $conexion->connect_errno;
if ($error != null) { // hay error
echo "<p>Error $error conectando a la base de datos: $conexion->connect_error</p>";
die(); // termina la ejecución del guion
}@es el operador de control de errores: delante de una expresión, hace que se ignore el aviso que pudiera producir (aquí, para que no aparezca el warning de PHP y solo se vea el mensaje propio).die()termina el guion; puede recibir un mensaje que se muestra antes de terminar.
Otras operaciones con la conexión:
select_db('otra_bd')(omysqli_select_db): cambia de base de datos sin reconectar. El usuario necesita permisos en la nueva.close()(omysqli_close): al acabar una conexión se debe ejecutar el métodoclosepara liberar los recursos que utiliza.
$conexion->select_db('otra_bd');
$conexion->close();Contexto actual: desde PHP 8.1, si la conexión falla,
new mysqli(...)lanza una excepción y el@no la detiene, así que elifno llega a ejecutarse; habría que capturarla contry/catch(apartado 4.1).
3.1.2 Ejecución de consultas
La forma más directa de ejecutar una consulta con MySQLi es el método query, equivalente a la función mysqli_query. No existen exec ni mysqli_exec en MySQLi (exec es de PDO).
- Consulta de acción (
INSERT,UPDATE,DELETE): devuelvetruesi se ejecuta bien yfalsesi no. El número de registros afectados está en la propiedadaffected_rows(omysqli_affected_rows). - Consulta de selección (
SELECT): devuelve un objeto resultado de la clasemysqli_result(apartado 3.1.4).
@$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
if ($conexion->connect_errno == null) {
$resultado = $conexion->query('DELETE FROM libros WHERE paginas < 100');
if ($resultado) {
echo "<p>Se han borrado $conexion->affected_rows libros.</p>";
}
$conexion->close();
}query() admite un segundo parámetro que afecta a cómo se traen internamente los resultados, no a cómo se usan después:
| Opción | Cómo trae los datos | Cuándo conviene |
|---|---|---|
MYSQLI_STORE_RESULT (por defecto) |
Todos juntos, y los guarda en local | Resultados de tamaño normal |
MYSQLI_USE_RESULT |
Según se van necesitando, de forma progresiva | Consultas que devuelven una enorme cantidad de datos |
$resultado = $conexion->query('SELECT titulo, paginas FROM libros', MYSQLI_USE_RESULT);Error frecuente: es al revés de lo que sugiere “store”:
MYSQLI_STORE_RESULTno recupera los datos de forma progresiva, los almacena todos de golpe. El progresivo esMYSQLI_USE_RESULT, y por eso es el adecuado para resultados enormes (no llena la memoria).
Otra forma es real_query (o mysqli_real_query), que siempre devuelve true o false. Si la consulta devuelve filas, se recogen después con store_result (todas) o use_result (según se necesiten).
Los resultados ocupan memoria mientras se usan; cuando ya no hacen falta se liberan con free() de mysqli_result (o mysqli_free_result):
$resultado->free();3.1.3 Transacciones
Una transacción es un grupo de sentencias que se aplican todas o ninguna. Ejemplo: prestar el último ejemplar de un libro exige restar uno del inventario y apuntar el préstamo; si la segunda falla, la primera debe deshacerse.
commit: confirma los cambios de la transacción; quedan grabados.rollback: revierte los cambios; la base de datos vuelve a como estaba al empezar.
Las transacciones solo funcionan si el motor de las tablas las soporta (InnoDB sí; MyISAM no). Con InnoDB, por defecto cada consulta va en su propia transacción y se confirma sola (modo autocommit). Por eso, en el modo por defecto no es posible revertir los cambios de una consulta de acción: cada una se confirma en cuanto se ejecuta.
Para utilizar transacciones por código con MySQLi se usa el método autocommit (función mysqli_autocommit) para deshabilitar el comportamiento por defecto. No es una propiedad, y beginTransaction es de PDO.
$conexion->autocommit(false); // deshabilita la confirmación automáticaA partir de ahí, las operaciones abren una transacción que se cierra con:
commit()(omysqli_commit): confirma; devuelvetrueofalse.rollback()(omysqli_rollback): revierte; devuelvetrueofalse.
Al terminar una transacción empieza otra automáticamente.
Ejemplo análogo al del temario: mover un ejemplar de un libro de una sede a otra en una tabla ejemplares (libro, sede, cantidad), donde la sede 1 tiene 2 ejemplares del libro 3 y la sede 2 no tiene ninguna fila de ese libro:
$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
$conexion->autocommit(false);
$ok1 = $conexion->query('UPDATE ejemplares SET cantidad = 1 WHERE libro = 3 AND sede = 1');
$ok2 = $conexion->query('INSERT INTO ejemplares (libro, sede, cantidad) VALUES (3, 2, 1)');
if ($ok1 && $ok2) {
$conexion->commit(); // las dos han ido bien: se graban
echo '<p>Ejemplar trasladado.</p>';
} else {
$conexion->rollback(); // alguna ha fallado: se deshace también la otra
echo '<p>No se ha podido trasladar el ejemplar.</p>';
}
$conexion->close();La segunda vez que se ejecuta, el INSERT falla (la fila ya existe) y el rollback deshace también el UPDATE.
El flujo de una transacción es el mismo con las dos extensiones; solo cambia cómo se abre:
flowchart TD
A["Desactivar el autocommit<br/>MySQLi: autocommit(false)<br/>PDO: beginTransaction()"] --> B["Sentencia 1: UPDATE"]
B --> C["Sentencia 2: INSERT"]
C --> D{"¿Han ido bien todas?"}
D -->|"Sí"| E["commit(): los cambios quedan grabados"]
D -->|"No"| F["rollback(): la base de datos vuelve<br/>a como estaba al empezar"]
Con un motor sin transacciones (MyISAM), el rollback no puede deshacer nada: cada sentencia ya quedó grabada al ejecutarse.
Error frecuente: con MyISAM no hay transacciones con ninguna extensión. No es cierto que MySQLi pueda usarlas sobre MyISAM y PDO no: depende del motor, no de la extensión.
3.1.4 Obtención y utilización de conjuntos de resultados
Un SELECT devuelve un objeto mysqli_result, que también tiene interfaz dual (cada método tiene su función). Para obtener un array a partir de un conjunto de resultados con MySQLi se usan fetch_array, fetch_assoc o fetch_row. Cada llamada devuelve un registro y avanza al siguiente.
| Método (función) | Devuelve | Acceso al título |
|---|---|---|
fetch_array() (mysqli_fetch_array) |
Array con claves numéricas y asociativas (por defecto) | $fila['titulo'] o $fila[0] |
fetch_array(MYSQLI_ASSOC) = fetch_assoc() |
Array asociativo | $fila['titulo'] |
fetch_array(MYSQLI_NUM) = fetch_row() |
Array numérico | $fila[0] |
fetch_object() |
Objeto con una propiedad por campo | $fila->titulo |
El parámetro de fetch_array admite MYSQLI_NUM, MYSQLI_ASSOC y MYSQLI_BOTH (el comportamiento por defecto).
Error frecuente: en MySQLi no existe
fetchenmysqli_result.fetches de PDO y, en MySQLi, de las consultas preparadas (mysqli_stmt, apartado 3.1.5).
$resultado = $conexion->query('SELECT titulo, paginas FROM libros WHERE paginas < 250');
$libro = $resultado->fetch_array(); // primer registro
echo "<p>{$libro['titulo']}: {$libro[1]} páginas.</p>"; // vale el nombre o el númeroPara recorrer todos los registros se aprovecha que los métodos devuelven null cuando no quedan más:
$resultado = $conexion->query('SELECT titulo, paginas FROM libros WHERE paginas < 250');
$libro = $resultado->fetch_object();
while ($libro != null) {
echo "<p>$libro->titulo: $libro->paginas páginas.</p>";
$libro = $resultado->fetch_object();
}Forma abreviada habitual, que asigna y comprueba en la misma condición:
while ($libro = $resultado->fetch_assoc()) {
echo "<p>{$libro['titulo']}</p>";
}Error frecuente: dentro de una cadena con comillas dobles,
"$libro->titulo"funciona, pero"$libro['titulo']"no: un índice entre comillas exige llaves,"{$libro['titulo']}", o concatenar con..
Bootstrap. Para no perder tiempo en CSS se recomienda un framework de estilos ya hecho como Bootstrap, que da páginas responsive con clases predefinidas (container, table, btn btn-success…). Basta enlazar su hoja de estilos en el <head>.
Ejemplo resuelto (página con formulario de selección). Página que muestra los libros de un género elegido en una lista desplegable de la misma página:
<?php
$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
$generos = $conexion->query('SELECT cod, nombre FROM generos ORDER BY nombre');
?>
<form action="" method="post"> <!-- action vacío: se envía a la misma página -->
<select name="genero">
<?php while ($g = $generos->fetch_object()) { ?>
<option value="<?= $g->cod ?>"><?= $g->nombre ?></option>
<?php } ?>
</select>
<button type="submit" name="ver">Ver libros</button>
</form>
<?php
if (isset($_POST['ver'])) { // solo si se ha enviado el formulario
$cod = $conexion->real_escape_string($_POST['genero']);
$libros = $conexion->query("SELECT titulo FROM libros WHERE genero = '$cod'");
while ($l = $libros->fetch_object()) {
echo "<p>$l->titulo</p>";
}
}
$conexion->close();<?= expr ?>es la forma corta de<?php echo expr; ?>.real_escape_stringneutraliza las comillas del dato recibido. La forma recomendada es la del apartado siguiente: consultas preparadas.
3.1.5 Consultas preparadas
Cada consulta que llega al servidor se analiza antes de ejecutarse. Una consulta preparada se analiza una vez, queda almacenada en el servidor y se ejecuta las veces que haga falta. Tiene dos ventajas:
- Rapidez en sentencias que se repiten (por ejemplo, muchas inserciones).
- Seguridad frente a la inyección SQL: los valores de los parámetros se envían después, por un protocolo distinto, y no necesitan ser escapados.
Inyección SQL: ocurre cuando un dato de un formulario se pega dentro de la sentencia. Si un usuario escribe en el campo de búsqueda ' OR '1'='1, la consulta "SELECT * FROM usuarios WHERE nombre = '$nombre'" pasa a ser SELECT * FROM usuarios WHERE nombre = '' OR '1'='1', que devuelve todas las filas. Con una consulta preparada, ese texto se trata como un valor, nunca como SQL.
Con MySQLi, las consultas preparadas usan la clase mysqli_stmt. Un objeto de esa clase se obtiene con stmt_init() de mysqli (o mysqli_stmt_init). Pasos:
stmt_init(): obtener el objetomysqli_stmt.prepare($sql)(mysqli_stmt_prepare): preparar la consulta en el servidor.execute()(mysqli_stmt_execute): ejecutarla, tantas veces como haga falta.close()(mysqli_stmt_close): liberarla cuando ya no se necesite.
El intercambio entre PHP y el servidor muestra por qué la sentencia se analiza una sola vez:
sequenceDiagram
participant P as Guion PHP
participant M as Servidor MySQL
P->>M: prepare con la sentencia y sus ?
M-->>P: Sentencia analizada y almacenada (mysqli_stmt)
loop Una vez por cada fila
P->>P: bind_param asigna los valores
P->>M: execute envía solo los valores
M-->>P: Resultado
end
P->>M: close libera la sentencia
Lo habitual es saltarse el paso 1: el primer paso para crear una consulta preparada con MySQLi es utilizar el método prepare para hacerle llegar el SQL al servidor. $conexion->prepare($sql) devuelve directamente el objeto mysqli_stmt, así que stmt_init solo hace falta si se quiere crear el objeto antes de tener la sentencia.
Parámetros. Preparar una sentencia con valores fijos sirve de poco. En su lugar se pone un ? en la posición de cada valor:
$stmt->prepare('INSERT INTO generos (cod, nombre) VALUES (?, ?)');Antes de ejecutar, los ? se sustituyen por valores con bind_param (o mysqli_stmt_bind_param), en una sola llamada que recibe todos los valores. Su primer argumento es una cadena con un carácter por parámetro que indica su tipo:
| Carácter | Tipo del parámetro |
|---|---|
i |
Número entero |
d |
Número real (doble precisión) |
s |
Cadena de texto |
b |
Contenido binario (BLOB) |
$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
$stmt = $conexion->stmt_init();
$stmt->prepare('INSERT INTO generos (cod, nombre) VALUES (?, ?)');
$cod = 'TEA';
$nombre = 'Teatro';
$stmt->bind_param('ss', $cod, $nombre); // una llamada: 'ss' = dos cadenas
$stmt->execute();
$stmt->close();
$conexion->close();Error frecuente: con MySQLi, antes de ejecutar una consulta preparada se asignan los valores con una llamada al método
bind_param, no una llamada por parámetro (eso esbindParamde PDO, apartado 3.2.4).
Error frecuente:
bind_paramexige variables, no literales.$stmt->bind_param('ss', 'TEA', 'Teatro');da error, porque los parámetros se pasan por referencia (la función guarda un enlace a la variable, no una copia del valor).
Como bind_param enlaza variables, basta cambiar su valor y volver a llamar a execute() para repetir la consulta con otros datos.
Recoger resultados. En las preparadas que devuelven filas, bind_result (mysqli_stmt_bind_result) asigna cada campo a una variable, y fetch (mysqli_stmt_fetch) avanza de registro y rellena esas variables:
$stmt = $conexion->stmt_init();
$stmt->prepare('SELECT titulo, paginas FROM libros WHERE genero = ?');
$genero = 'NOV';
$stmt->bind_param('s', $genero);
$stmt->execute();
$stmt->bind_result($titulo, $paginas); // el 1.er campo irá a $titulo y el 2.º a $paginas
while ($stmt->fetch()) {
echo "<p>$titulo: $paginas páginas.</p>";
}
$stmt->close();Control de errores. prepare() y execute() devuelven un booleano, que permite detectar fallos:
$stmt = $conexion->stmt_init();
$id = 1;
if (!$stmt->prepare('SELECT titulo FROM libros WHERE id = ?')) {
echo 'Se ha producido un error: ' . $conexion->error; // error es una propiedad, sin paréntesis
die();
}
$stmt->bind_param('i', $id);
if (!$stmt->execute()) {
echo 'Error al ejecutar: ' . $stmt->error;
}Ejemplo resuelto (actualizar con preparada). Formulario que cambia el número de páginas de un libro elegido:
<?php
$conexion = new mysqli('localhost', 'bibliotecario', 'secreto', 'biblioteca');
if (isset($_POST['actualizar'])) {
$id = (int) $_POST['id'];
$paginas = (int) $_POST['paginas'];
$stmt = $conexion->stmt_init();
$stmt->prepare('UPDATE libros SET paginas = ? WHERE id = ?');
$stmt->bind_param('ii', $paginas, $id); // dos enteros, en el orden de los ?
$stmt->execute();
echo "<p>Filas modificadas: $stmt->affected_rows</p>";
$stmt->close();
}
$conexion->close();
?>
<form action="" method="post">
Id: <input type="number" name="id">
Páginas: <input type="number" name="paginas">
<button type="submit" name="actualizar">Actualizar</button>
</form>3.2 PHP Data Objects (PDO)
MySQLi es buena opción si la aplicación va a usar siempre MySQL: da acceso a todas sus características y es rápida. Pero si algún día hay que cambiar de gestor, habrá que reprogramar gran parte del acceso a datos. Si existe esa posibilidad, conviene una capa de abstracción de acceso a datos; hay varias (ODBC, por ejemplo), y la más recomendable hoy es PDO.
El objetivo de PDO es que, si se cambia de servidor, los cambios en el código sean mínimos, no nulos. PDO no abstrae por completo el gestor: no modifica las sentencias SQL para adaptarlas a cada servidor. Por eso, usando PDO no se puede cambiar de gestor sin más que adaptar las sentencias de conexión: si el SQL usa algo propio de MySQL, también habrá que cambiarlo. Para eso haría falta una capa de abstracción completa.
Otras características:
- Necesita un driver o controlador específico para cada tipo de base de datos; los disponibles se ven con
phpinfo(). - Es solo orientada a objetos: al contrario que MySQLi, no ofrece interfaz dual; no hay funciones alternativas.
- Su máximo partido se saca con POO, creando una clase por tabla con los métodos de su CRUD; eso se verá en la unidad de POO.
CRUD son las siglas de las cuatro operaciones básicas sobre una tabla: Create (INSERT), Read (SELECT), Update (UPDATE) y Delete (DELETE).
3.2.1 Establecimiento de conexiones
La conexión es un objeto de la clase PDO. Su constructor recibe (solo el primero es obligatorio):
- Origen de datos (DSN): cadena que indica el controlador y, tras dos puntos, sus parámetros.
- Usuario.
- Contraseña.
- Opciones de conexión, en un array.
$host = "localhost";
$db = "biblioteca";
$user = "bibliotecario";
$pass = "secreto";
$dsn = "mysql:host=$host;dbname=$db"; // controlador mysql y sus parámetros
$conexion = new PDO($dsn, $user, $pass);
// Los datos en variables: si cambian, se cambian en un solo sitioParámetros de la DSN del controlador MySQL, separados por punto y coma tras el prefijo mysql::
| Parámetro | Significado |
|---|---|
host |
Nombre o IP del servidor |
port |
Puerto TCP en que escucha el servidor |
dbname |
Base de datos |
unix_socket |
Socket de MySQL en sistemas Unix |
charset |
Codificación de los datos transmitidos |
El número de puerto TCP se indica en la cadena DSN que indica el origen de datos, con port, no en el array de opciones. La codificación UTF-8 con emojis se indica también ahí:
$dsn = "mysql:host=$host;port=3306;dbname=$db;charset=utf8mb4";Atributos de la conexión. getAttribute consulta el estado de la conexión y setAttribute cambia parámetros:
$version = $conexion->getAttribute(PDO::ATTR_SERVER_VERSION); // versión del servidor
echo "Versión: $version";
$conexion->setAttribute(PDO::ATTR_CASE, PDO::CASE_UPPER); // nombres de columna en mayúsculasEl atributo más importante es PDO::ATTR_ERRMODE, que decide qué hace PDO ante un error:
| Valor | Comportamiento | Uso |
|---|---|---|
PDO::ERRMODE_SILENT |
Por defecto: establece el código de error y no muestra nada | Producción |
PDO::ERRMODE_WARNING |
Además emite un E_WARNING, sin interrumpir la ejecución |
Depuración y pruebas |
PDO::ERRMODE_EXCEPTION |
Además lanza una PDOException, que se captura con try/catch (apartado 4.1) |
Control de errores |
$conexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);Contexto actual: desde PHP 8.0 el modo por defecto es
ERRMODE_EXCEPTION, noERRMODE_SILENT. Aun así se fija siempre de forma explícita, como hace el temario.
Si la conexión falla, new PDO(...) lanza siempre una PDOException, sea cual sea el modo de errores (que solo se aplica una vez creada la conexión). Por eso, al utilizar PDO, si no se puede establecer una conexión con el gestor, se lanza una excepción que es conveniente capturar; si no se captura, el guion se detiene con un error fatal (Uncaught PDOException). El apartado 4.1 muestra cómo capturarla.
Cerrar la conexión. La conexión vive mientras viva el objeto. Se cierra destruyéndolo: asignando null a la variable (y a cualquier otra que lo referencie). No hay método close.
$conexion = null;3.2.2 Ejecución de consultas
PDO separa las dos clases de sentencias del apartado 2.3.7, y no se pueden usar indistintamente query y exec:
| Método | Para | Devuelve |
|---|---|---|
exec |
Consultas de acción (INSERT, DELETE, UPDATE) |
El número de registros afectados |
query |
Consultas que devuelven datos (SELECT) |
Un objeto PDOStatement con el conjunto de resultados |
$registros = $conexion->exec('DELETE FROM libros WHERE paginas < 100');
echo "<p>Se han borrado $registros libros.</p>";
$resultado = $conexion->query('SELECT id, titulo FROM libros'); // PDOStatementAnalogía con Java: es la misma separación que JDBC:
executeUpdatedevuelve unintcon las filas afectadas yexecuteQuerydevuelve unResultSet.
Transacciones. PDO trabaja por defecto en modo autocommit: confirma cada sentencia automáticamente. Para usar transacciones por código con PDO se ejecuta el método beginTransaction:
beginTransaction(): deshabilita el autocommit y comienza una transacción.commit(): confirma la transacción.rollback(): revierte sus cambios.
Tras commit o rollback se vuelve al modo automático.
$ok = true;
$conexion->beginTransaction();
if ($conexion->exec('UPDATE ejemplares SET cantidad = 1 WHERE libro = 5 AND sede = 1') != 1) $ok = false;
if ($conexion->exec('INSERT INTO ejemplares (libro, sede, cantidad) VALUES (5, 2, 2)') != 1) $ok = false;
if ($ok) {
$conexion->commit(); // todo bien: se graban los cambios
} else {
$conexion->rollback(); // algo falló: se deshacen
}Aquí se comprueba que cada sentencia afecta exactamente a un registro, y si no, se revierte todo.
Motores sin transacciones. No todos los motores las soportan: MyISAM no. En ese caso, PDO ejecuta beginTransaction sin errores, pero no podrá revertir los cambios si se llama a rollback. Por eso:
- Usar
beginTransactioncorrectamente no garantiza que siempre se pueda revertir conrollback: depende del motor. - Intentar comenzar una transacción con un motor que no las soporta no da ningún error.
Error frecuente: la trampa está en la palabra “error”:
beginTransactionno falla con MyISAM; lo que falla en silencio es elrollback.
3.2.3 Obtención y utilización de conjuntos de resultados
Con PDO, para obtener un array a partir de un conjunto de resultados se usa el método fetch de PDOStatement (no existen fetch_array, fetch_assoc ni fetch_row, que son de MySQLi). Devuelve un registro, o false cuando no quedan más:
$resultado = $conexion->query('SELECT titulo, paginas FROM libros');
while ($registro = $resultado->fetch()) {
echo $registro['titulo'] . ': ' . $registro['paginas'] . '<br>';
}El comportamiento por defecto de fetch es devolver un array con claves numéricas y asociativas (equivale a PDO::FETCH_BOTH). Se cambia con un parámetro:
| Constante | Devuelve |
|---|---|
PDO::FETCH_ASSOC |
Solo array asociativo |
PDO::FETCH_NUM |
Solo array numérico |
PDO::FETCH_BOTH |
Array numérico y asociativo (por defecto) |
PDO::FETCH_OBJ |
Objeto con una propiedad por campo |
PDO::FETCH_LAZY |
El objeto y el array con clave dual a la vez |
PDO::FETCH_BOUND |
true, y asigna los campos a variables enlazadas con bindColumn |
$resultado = $conexion->query('SELECT titulo, paginas FROM libros');
while ($libro = $resultado->fetch(PDO::FETCH_OBJ)) {
echo $libro->titulo . ': ' . $libro->paginas . '<br>';
}Con PDO::FETCH_BOUND, bindColumn se llama una vez por columna con su número (empezando en 1) y la variable:
$resultado = $conexion->query('SELECT titulo, paginas FROM libros');
$resultado->bindColumn(1, $titulo);
$resultado->bindColumn(2, $paginas);
while ($resultado->fetch(PDO::FETCH_BOUND)) {
echo "$titulo: $paginas<br>";
}fetchAll trae todas las filas de golpe en un array. Es cómodo cuando no se esperan muchos resultados; con muchísimas filas puede agotar la memoria.
$resultado = $conexion->query('SELECT cod, nombre FROM generos ORDER BY nombre');
$generos = $resultado->fetchAll(PDO::FETCH_ASSOC);
foreach ($generos as $g) {
echo $g['cod'] . ' ' . $g['nombre'] . '<br>';
}Analogía con Java:
fetchhace lo quers.next()y losgetString()juntos de JDBC: avanza y devuelve la fila.fetchAlles como volcar elResultSeten unaList.
3.2.4 Consultas preparadas
El procedimiento es el mismo que con MySQLi y los métodos se llaman casi igual. prepare de la clase PDO devuelve un PDOStatement. Los parámetros se marcan con ? o con nombre, precedido de dos puntos:
$stmt = $conexion->prepare('INSERT INTO generos (cod, nombre) VALUES (?, ?)');
$stmt = $conexion->prepare('INSERT INTO generos (cod, nombre) VALUES (:cod, :nombre)');Con PDO, antes de ejecutar una consulta preparada se asignan los valores con una llamada al método bindParam por cada parámetro. Con ?, se indica la posición (desde 1, como en bindColumn); con nombres, el nombre:
$cod = 'TEA';
$nombre = 'Teatro';
// Con signos de interrogación
$stmt = $conexion->prepare('INSERT INTO generos (cod, nombre) VALUES (?, ?)');
$stmt->bindParam(1, $cod);
$stmt->bindParam(2, $nombre);
$stmt->execute();
// Con parámetros con nombre
$stmt = $conexion->prepare('INSERT INTO generos (cod, nombre) VALUES (:cod, :nombre)');
$stmt->bindParam(':cod', $cod);
$stmt->bindParam(':nombre', $nombre);
$stmt->execute();Igual que en MySQLi, bindParam exige variables, no literales.
| MySQLi | PDO | |
|---|---|---|
| Preparar | stmt_init() + prepare() |
prepare() |
| Marcadores | Solo ? |
? o :nombre |
| Asignar valores | bind_param('tipos', $v1, $v2…): una llamada |
bindParam(pos o nombre, $v): una por parámetro |
| Ejecutar | execute() |
execute() |
| Leer resultados | bind_result() + fetch() |
fetch() |
Valores en execute (forma lazy). También se pueden pasar los valores en un array directamente a execute(), sin bindParam. Es la forma más cómoda y la habitual:
$stmt = $conexion->prepare('INSERT INTO generos (cod, nombre) VALUES (:cod, :nombre)');
$stmt->execute([':cod' => 'TEA', ':nombre' => 'Teatro']); // aquí sí valen literales
$stmt = $conexion->prepare('SELECT * FROM libros WHERE id = ?');
$stmt->execute([3]); // con ?, un array en orden
$libro = $stmt->fetch(PDO::FETCH_ASSOC);El nombre viene de la carga diferida (lazy loading), patrón que retrasa la carga o inicialización de un objeto hasta el momento en que se usa.
4. Errores y manejo de excepciones
Hay errores de programación (que el editor detecta o que aparecen al ejecutar) y errores ajenos al programa: el servidor de bases de datos no está disponible, un registro se ha borrado mientras se usaba… La aplicación tiene que comportarse de forma sólida también en esos casos.
PHP clasifica los errores en niveles, cada uno con una constante:
| Constante | Nivel |
|---|---|
E_ERROR |
Errores fatales: interrumpen la ejecución |
E_WARNING |
Advertencias: el guion continúa |
E_NOTICE |
Avisos que pueden indicar un error |
E_ALL |
Todos los niveles |
La configuración inicial se hace en php.ini:
error_reporting: indica qué niveles de error se notifican. Su valor combina constantes con operadores de bits; el predeterminado esE_ALL & ~E_NOTICE(todos salvo los avisos). No existenerror_noticenishow_errors.display_errors: conOn(por defecto), los mensajes se envían a la salida y se ven en el navegador. Se desactiva (Off) en producción.
Error frecuente:
display_errorsno elige qué errores se notifican, sino si se muestran en la página. Lo que se notifica lo decideerror_reporting.
Contexto actual: desde PHP 8.0 el valor por defecto de
error_reportingesE_ALL.
Leer E_ALL & ~E_NOTICE: ~ invierte los bits de E_NOTICE y & los combina, es decir, “todos y no los avisos”.
Desde el código, la función error_reporting() cambia el nivel en un punto concreto:
error_reporting(E_ALL & ~E_NOTICE & ~E_WARNING); // deja de notificar advertencias
$media = $total / $cantidad; // si $cantidad es 0, no se ve el aviso
error_reporting(E_ALL & ~E_NOTICE); // restaura el nivel anteriorContexto actual: desde PHP 8.0 dividir entre cero lanza una excepción
DivisionByZeroError; ya no es un warning.
Para tener más control, set_error_handler sustituye el tratamiento de PHP por una función propia, que se ejecuta cada vez que se produce un error: permite personalizar el comportamiento de PHP cuando se produce un error, pero no sea cual sea su nivel: los errores fatales (E_ERROR, E_PARSE, E_CORE_ERROR…) no se pueden tratar con ella y detienen el guion igualmente. La función recibe dos parámetros obligatorios (nivel y mensaje) y hasta tres opcionales (fichero, línea y volcado de variables). restore_error_handler vuelve al manejador anterior.
set_error_handler("miGestorDeErrores");
$valor = $datos['clave_inexistente']; // provoca un aviso
restore_error_handler();
function miGestorDeErrores($nivel, $mensaje)
{
switch ($nivel) {
case E_WARNING:
echo "Error de tipo WARNING: $mensaje.<br>";
break;
default:
echo "Error de tipo no especificado: $mensaje.<br>";
}
}4.1 Excepciones
Desde PHP 5 existe un modelo de excepciones como el de otros lenguajes:
- El código que puede fallar va en un bloque
try. - Cuando se produce un error, se lanza una excepción con
throw. - Tras el
tryva normalmente uno o más bloquescatchque procesan el error. Pero no es cierto que cada bloquetrydeba tener al menos un bloquecatchasociado: desde PHP 5.5 existefinally, y untrypuede llevar solofinally, sin ningúncatch. Se ejecuta elcatchcuyo tipo coincida con la excepción lanzada (tiene sentido con varias clases de excepción derivadas deException). - Si el
trytermina sin excepciones, la ejecución sigue tras el últimocatch.
try {
if ($cantidad == 0) {
throw new Exception("División por cero.");
}
$media = $total / $cantidad;
} catch (Exception $e) {
echo "Se ha producido el siguiente error: " . $e->getMessage();
}PHP ofrece la clase base Exception. Al lanzarla se puede pasar, opcionalmente, un mensaje y un código de error, que se recuperan con:
getMessage(): el mensaje.getCode(): el código de error.
Analogía con Java: es el mismo
try/catch/throw, con dos diferencias: en PHP elcatchlleva el tipo y la variable con$(catch (Exception $e)), y no existethrowsen la cabecera de los métodos ni excepciones comprobadas.
Las funciones internas de PHP y extensiones como MySQLi usan el sistema de errores del apartado anterior. Las extensiones modernas orientadas a objetos, como PDO, usan excepciones, y definen su propia clase heredando de Exception: PDO lanza PDOException. Por eso no se puede configurar PDO para que genere excepciones con el manejador base Exception: con PDO::ERRMODE_EXCEPTION lanza siempre PDOException.
Ampliación: la clase
ErrorExceptionpermite convertir los errores clásicos de PHP en excepciones.
Para usar excepciones con PDO se configura la conexión:
$conexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);Ejemplo con una contraseña equivocada:
$host = "localhost";
$db = "biblioteca";
$user = "bibliotecario";
$pass = "1234"; // la buena es "secreto"
$dsn = "mysql:host=$host;dbname=$db";
try {
$conexion = new PDO($dsn, $user, $pass);
$conexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $ex) {
die("Error en la conexión, mensaje de error: " . $ex->getMessage());
}Muestra:
Error en la conexión, mensaje de error: SQLSTATE[HY000] [1045] Access denied for user 'bibliotecario'@'localhost' (using password: YES)Error frecuente: si el
catchcapturaException, también atrapa laPDOException, porquePDOExceptionhereda deException. Lo incorrecto es pensar que PDO lanzaException: lanzaPDOException.
El patrón completo de una conexión PDO con excepciones queda así:
flowchart TD
A["try"] --> B["new PDO($dsn, $user, $pass)"]
B -->|"falla: datos erróneos o servidor caído"| X["catch (PDOException $ex)"]
B -->|"conecta"| C["setAttribute(ATTR_ERRMODE, ERRMODE_EXCEPTION)"]
C --> D["prepare / execute / query"]
D -->|"falla una sentencia"| X
D -->|"todo correcto"| E["Se usan los resultados"]
X --> Y["$ex->getMessage(): se muestra o se registra el error"]
E --> Z["$conexion = null: se cierra la conexión"]
4.2 Ampliación: aplicación CRUD completa con PDO
Este apartado reúne toda la unidad en una aplicación de gestión de la tabla libros de la base de datos biblioteca (apartado 2.3.1), con usuario bibliotecario y contraseña secreto. Tiene cinco páginas:
| Página | Operación | Recibe | SQL |
|---|---|---|---|
libros.php |
Listado con botones | Nada | SELECT id, titulo … ORDER BY titulo |
nuevo.php |
Alta (formulario) | El formulario, por POST | INSERT (y SELECT de generos para la lista) |
ficha.php |
Detalle de un libro | id por GET |
SELECT * … WHERE id = :id |
editar.php |
Modificación (formulario relleno) | id por GET y el formulario por POST |
SELECT + UPDATE … WHERE id = :id |
eliminar.php |
Baja y mensaje | id por POST |
DELETE … WHERE id = ? |
La navegación entre las cinco páginas parte siempre del listado:
flowchart TD
L["libros.php<br/>listado (SELECT)"]
L -->|"Nuevo"| N["nuevo.php<br/>INSERT, se envía a sí misma por POST"]
L -->|"?id= por GET"| F["ficha.php<br/>SELECT ... WHERE id"]
L -->|"?id= por GET"| E["editar.php<br/>SELECT + UPDATE, se envía a sí misma por POST"]
L -->|"id por POST"| D["eliminar.php<br/>DELETE"]
N & F & E & D -.-> V["Vuelta al listado: enlace Volver,<br/>o header Location si falta el id"]
V -.-> L
Antes del código, cinco piezas de PHP que se usan en todas las páginas:
require 'conexion.php';incluye el contenido de otro fichero en ese punto (para escribir la conexión una sola vez). Si el fichero no existe, el guion se detiene.$_GET['id']lee un parámetro de la URL (ficha.php?id=3);$_POST['titulo'], un campo de un formulario enviado conmethod="post".isset()comprueba si existe.header('Location: libros.php');redirige el navegador a otra página. Tiene que ejecutarse antes de enviar nada de HTML (ni un espacio), y va seguido deexit;para que el resto del guion no se ejecute.htmlspecialchars($texto)convierte<,>,&y las comillas en entidades al mostrar datos, para que un título con<script>se vea como texto y no se ejecute.- Sintaxis alternativa para mezclar con HTML:
<?php foreach ($libros as $l): ?> … <?php endforeach; ?>y<?php if (…): ?> … <?php else: ?> … <?php endif; ?>.
conexion.php: conexión común, con las excepciones activadas.
<?php
$host = "localhost";
$db = "biblioteca";
$user = "bibliotecario";
$pass = "secreto";
$dsn = "mysql:host=$host;dbname=$db;charset=utf8mb4";
try {
$conexion = new PDO($dsn, $user, $pass);
$conexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $ex) {
die("<p>Error de conexión: " . $ex->getMessage() . "</p>");
}Error frecuente: un fichero que solo contiene PHP no lleva
?>al final. Un salto de línea detrás del cierre se enviaría como salida y haría fallar losheader()posteriores.
libros.php: listado.
<?php
require 'conexion.php';
try {
$resultado = $conexion->query('SELECT id, titulo FROM libros ORDER BY titulo');
$libros = $resultado->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOException $ex) {
$error = $ex->getMessage();
}
$conexion = null;
?>
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Libros</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css">
</head>
<body class="container">
<h1 class="text-center">Gestión de libros</h1>
<a href="nuevo.php" class="btn btn-success mb-2">Nuevo</a>
<?php if (isset($error)): ?>
<p class="text-danger">Error: <?= htmlspecialchars($error) ?></p>
<?php else: ?>
<table class="table table-dark">
<tr><th>Ficha</th><th>Id</th><th>Título</th><th>Acciones</th></tr>
<?php foreach ($libros as $libro): ?>
<tr>
<td><a href="ficha.php?id=<?= $libro['id'] ?>" class="btn btn-info">Ficha</a></td>
<td><?= $libro['id'] ?></td>
<td><?= htmlspecialchars($libro['titulo']) ?></td>
<td>
<a href="editar.php?id=<?= $libro['id'] ?>" class="btn btn-warning">Editar</a>
<form action="eliminar.php" method="post" class="d-inline">
<input type="hidden" name="id" value="<?= $libro['id'] ?>">
<button type="submit" class="btn btn-danger">Eliminar</button>
</form>
</td>
</tr>
<?php endforeach; ?>
</table>
<?php endif; ?>
</body>
</html>- El
idviaja en la URL de los enlaces (ficha.php?id=3) y se lee con$_GET['id']. - El botón de eliminar es un formulario con un campo oculto (
type="hidden"): una operación que modifica datos no debería ir en un simple enlace, que cualquiera puede abrir sin querer (o un buscador, al rastrear la página).
ficha.php: detalle de un libro.
<?php
if (!isset($_GET['id'])) { // sin id no hay nada que mostrar
header('Location: libros.php');
exit;
}
require 'conexion.php';
try {
$stmt = $conexion->prepare('SELECT * FROM libros WHERE id = :id');
$stmt->execute([':id' => $_GET['id']]);
$libro = $stmt->fetch(PDO::FETCH_OBJ); // false si no existe ese id
} catch (PDOException $ex) {
die('<p>Error: ' . $ex->getMessage() . '</p>');
}
$conexion = null;
if (!$libro) { // id inexistente: de vuelta al listado
header('Location: libros.php');
exit;
}
?>
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Ficha</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css">
</head>
<body class="container">
<h1><?= htmlspecialchars($libro->titulo) ?></h1>
<p>Id: <?= $libro->id ?></p>
<p>Autor: <?= htmlspecialchars($libro->autor) ?></p>
<p>Páginas: <?= $libro->paginas ?></p>
<p>Género: <?= $libro->genero ?></p>
<p><?= htmlspecialchars($libro->sinopsis ?? '') ?></p>
<a href="libros.php" class="btn btn-secondary">Volver</a>
</body>
</html>- La comprobación de
issety la redirección van antes de cualquier salida. $libro->sinopsis ?? ''(operador de fusión de null) usa''si la sinopsis esNULL; desde PHP 8.1, pasarnullahtmlspecialcharsda un aviso de obsolescencia.
nuevo.php: alta. El formulario se envía a la misma página; arriba se procesa si llega.
<?php
require 'conexion.php';
$mensaje = '';
if (isset($_POST['crear'])) { // se ha pulsado el botón Crear
$titulo = trim($_POST['titulo']);
$autor = trim($_POST['autor']);
if ($titulo == '' || $autor == '') {
$mensaje = 'El título y el autor son obligatorios.';
} else {
try {
$stmt = $conexion->prepare(
'INSERT INTO libros (titulo, autor, paginas, genero, sinopsis)
VALUES (:titulo, :autor, :paginas, :genero, :sinopsis)');
$stmt->execute([
':titulo' => $titulo,
':autor' => $autor,
':paginas' => $_POST['paginas'] === '' ? null : (int) $_POST['paginas'],
':genero' => $_POST['genero'],
':sinopsis' => $_POST['sinopsis'],
]);
$mensaje = 'Libro creado con el id ' . $conexion->lastInsertId() . '.';
} catch (PDOException $ex) {
$mensaje = 'No se ha podido crear: ' . $ex->getMessage();
}
}
}
try {
$generos = $conexion->query('SELECT cod, nombre FROM generos ORDER BY nombre')
->fetchAll(PDO::FETCH_OBJ);
} catch (PDOException $ex) {
die('<p>Error: ' . $ex->getMessage() . '</p>');
}
$conexion = null;
?>
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Nuevo libro</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css">
</head>
<body class="container">
<h1 class="text-center">Nuevo libro</h1>
<p><?= htmlspecialchars($mensaje) ?></p>
<form action="nuevo.php" method="post">
<label class="form-label">Título</label>
<input type="text" name="titulo" class="form-control">
<label class="form-label">Autor</label>
<input type="text" name="autor" class="form-control">
<label class="form-label">Páginas</label>
<input type="number" name="paginas" class="form-control">
<label class="form-label">Género</label>
<select name="genero" class="form-select">
<?php foreach ($generos as $g): ?>
<option value="<?= $g->cod ?>"><?= htmlspecialchars($g->nombre) ?></option>
<?php endforeach; ?>
</select>
<label class="form-label">Sinopsis</label>
<textarea name="sinopsis" rows="6" class="form-control"></textarea>
<button type="submit" name="crear" class="btn btn-primary mt-2">Crear</button>
<button type="reset" class="btn btn-success mt-2">Limpiar</button>
<a href="libros.php" class="btn btn-info mt-2">Volver</a>
</form>
</body>
</html>- El
idno se pide: lo asignaAUTO_INCREMENT.lastInsertId()devuelve el que se acaba de generar. - El desplegable muestra el nombre del género pero envía su código: el texto visible va entre
<option>y</option>, y lo que se envía es el atributovalue. trimquita los espacios de los extremos;(int)convierte a entero; un campo numérico vacío se guarda comoNULL.type="reset"vacía el formulario sin enviarlo.
editar.php: modificación. Recibe el id por GET y el formulario por POST.
<?php
if (!isset($_GET['id'])) {
header('Location: libros.php');
exit;
}
require 'conexion.php';
$id = $_GET['id'];
$mensaje = '';
try {
if (isset($_POST['guardar'])) {
$stmt = $conexion->prepare(
'UPDATE libros SET titulo = :titulo, autor = :autor, paginas = :paginas,
genero = :genero, sinopsis = :sinopsis
WHERE id = :id');
$stmt->execute([
':titulo' => trim($_POST['titulo']),
':autor' => trim($_POST['autor']),
':paginas' => $_POST['paginas'] === '' ? null : (int) $_POST['paginas'],
':genero' => $_POST['genero'],
':sinopsis' => $_POST['sinopsis'],
':id' => $id,
]);
$mensaje = 'Cambios guardados.';
}
$stmt = $conexion->prepare('SELECT * FROM libros WHERE id = :id'); // datos actuales
$stmt->execute([':id' => $id]);
$libro = $stmt->fetch(PDO::FETCH_OBJ);
$generos = $conexion->query('SELECT cod, nombre FROM generos ORDER BY nombre')
->fetchAll(PDO::FETCH_OBJ);
} catch (PDOException $ex) {
die('<p>Error: ' . $ex->getMessage() . '</p>');
}
$conexion = null;
if (!$libro) {
header('Location: libros.php');
exit;
}
?>
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Editar libro</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css">
</head>
<body class="container">
<h1 class="text-center">Editar libro</h1>
<p><?= $mensaje ?></p>
<form action="editar.php?id=<?= $libro->id ?>" method="post">
<label class="form-label">Título</label>
<input type="text" name="titulo" class="form-control"
value="<?= htmlspecialchars($libro->titulo) ?>">
<label class="form-label">Autor</label>
<input type="text" name="autor" class="form-control"
value="<?= htmlspecialchars($libro->autor) ?>">
<label class="form-label">Páginas</label>
<input type="number" name="paginas" class="form-control" value="<?= $libro->paginas ?>">
<label class="form-label">Género</label>
<select name="genero" class="form-select">
<?php foreach ($generos as $g): ?>
<option value="<?= $g->cod ?>" <?= $g->cod == $libro->genero ? 'selected' : '' ?>>
<?= htmlspecialchars($g->nombre) ?>
</option>
<?php endforeach; ?>
</select>
<label class="form-label">Sinopsis</label>
<textarea name="sinopsis" rows="6" class="form-control"><?= htmlspecialchars($libro->sinopsis ?? '') ?></textarea>
<button type="submit" name="guardar" class="btn btn-primary mt-2">Guardar</button>
<a href="libros.php" class="btn btn-info mt-2">Volver</a>
</form>
</body>
</html>action="editar.php?id=…": al enviar el formulario por POST, la URL conserva elid, así que$_GET['id']sigue existiendo en la segunda carga. Sin eso, la página redirigiría al listado al guardar.- Los campos de texto se rellenan con el atributo
value; el<textarea>, con su contenido entre etiquetas (no tienevalue). - En el
<select>se marca conselectedla opción cuyo código coincide con el género actual del libro, usando el operador ternariocondición ? 'selected' : ''. - Se lee el libro después del
UPDATE, para que el formulario muestre los datos ya guardados.
eliminar.php: baja y mensaje.
<?php
if (!isset($_POST['id'])) {
header('Location: libros.php');
exit;
}
require 'conexion.php';
try {
$stmt = $conexion->prepare('DELETE FROM libros WHERE id = ?');
$stmt->execute([$_POST['id']]);
$mensaje = $stmt->rowCount() == 1 ? 'Libro eliminado.' : 'No existía ningún libro con ese id.';
} catch (PDOException $ex) {
$mensaje = 'No se ha podido eliminar: ' . $ex->getMessage();
}
$conexion = null;
?>
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Eliminar libro</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css">
</head>
<body class="container">
<p class="mt-3"><?= htmlspecialchars($mensaje) ?></p>
<a href="libros.php" class="btn btn-secondary">Volver</a>
</body>
</html>rowCount()dePDOStatementdevuelve los registros afectados por la última sentencia (comoexecen una consulta directa).
Error frecuente: si otra tabla tiene una clave ajena que apunta al registro (por ejemplo, préstamos de ese libro) y no se definió
ON DELETE CASCADE, el gestor rechaza el borrado por integridad referencial. ConERRMODE_EXCEPTIONllega comoPDOException, y elcatchmuestra el motivo en lugar de dejar la página en blanco.
Error frecuente: construir el SQL concatenando datos del usuario (
"DELETE FROM libros WHERE id = " . $_POST['id']) abre la puerta a la inyección SQL. Todo dato que llega de un formulario o de la URL va por un parámetro de una consulta preparada.
Ideas clave
- Dos vías desde PHP: extensión nativa (potencia y velocidad, un gestor) o PDO (misma sintaxis para varios gestores, pero no adapta el SQL). La antigua
mysqlestá desaconsejada; las recomendables son MySQLi y PDO. Ambas pueden usar el driver mysqlnd, que sustituye a libmysql. - MySQL: GPL con ediciones comerciales; motores MyISAM (rápido, por defecto en el temario, sin transacciones ni integridad referencial) e InnoDB (con ambas). Puerto 3306, configuración en
my.cnf([client],[mysqld],port,user,datadir). Servidor y clientes son paquetes distintos, pero al instalar el servidor se instalan también los clientes. - Herramientas:
mysql(sentencias, interactiva o por lotes con<),mysqladmin(administración, no interactiva),mysqlshow; phpMyAdmin (web, se instala aparte) y MySQL Workbench (nativa).-pclavesin espacio; mejor solo-p. - SQL:
SELECT … FROM … WHERE … ORDER BY;INSERT INTO t (cols) VALUES (vals);UPDATE t SET c = v WHERE …;DELETE FROM t WHERE …. SinWHERE,UPDATEyDELETEafectan a toda la tabla. Textos entre comillas;IS NULL. - MySQLi: interfaz dual; configuración en
php.ini; conexión con constructor oconnect; error enconnect_errno/connect_error;close.query/mysqli_query(acción:true/falseyaffected_rows; selección:mysqli_result).MYSQLI_USE_RESULTpara resultados enormes. Transacciones conautocommit(false),commit,rollback. Arrays confetch_array(ambas claves por defecto),fetch_assoc,fetch_row;fetch_object. Preparadas:stmt_init,prepare, una llamada abind_param('tipos', …)con variables,execute,bind_result+fetch,close. - PDO: solo objetos.
new PDO($dsn, $user, $pass), conportycharseten la DSN.execpara acción (devuelve registros afectados) yqueryparaSELECT(PDOStatement); no son intercambiables.beginTransaction,commit,rollback; con MyISAM no da error, pero no revierte.fetch(por defectoFETCH_BOTH),FETCH_ASSOC,FETCH_OBJ,fetchAll. Preparadas con?o:nombre,bindParampor cada parámetro o array enexecute. Se cierra con= null. - Errores: niveles con constantes (
E_ERROR,E_WARNING,E_NOTICE,E_ALL);error_reportingdecide qué se notifica ydisplay_errorssi se muestra (Offen producción);set_error_handleryrestore_error_handler. - Excepciones:
try,throw, uno o máscatch;ExceptioncongetMessageygetCode. PDO conERRMODE_EXCEPTIONlanzaPDOException, noException; un fallo de conexión connew PDOlanza siempre excepción y conviene capturarla. - CRUD con PDO: datos de conexión en un fichero común;
idpor GET conissety redirección conheader('Location: …')+exitantes de cualquier salida; consultas preparadas para todo dato del usuario;htmlspecialcharsal mostrar;<select>que muestra nombres y envía códigos, conselectedal editar.
Descargas