Actualizar y eliminar registros en MySQL: UPDATE y DELETE

Hola, ¿cómo están? Continuando con el curso de MySQL, hoy veremos cómo modificar y eliminar datos. Son las dos sentencias donde un descuido cuesta más caro, así que empezaremos por ahí.

¡Empecemos!

La regla que evita el 90 % de los desastres

Antes de la sintaxis, el hábito:

Escribe siempre el WHERE antes que el resto de la sentencia.

UPDATE pacientes SET telefono = '70000000';

Esa sentencia le pone el mismo teléfono a todos los pacientes de la base de datos. Sin confirmación, sin aviso, sin vuelta atrás.

Y esto no le pasa solo a los principiantes: es de los accidentes más frecuentes en producción, normalmente al ejecutar sin querer una sentencia a medio escribir.

El hábito de probar con SELECT

La forma de trabajar que recomiendo:

-- 1. Primero mira a quién vas a afectar
SELECT * FROM pacientes WHERE id = 3;

-- 2. Solo si el resultado es el esperado, ejecuta
UPDATE pacientes SET telefono = '76980510' WHERE id = 3;

Escribes el SELECT, compruebas que devuelve exactamente las filas que quieres tocar, y recién entonces cambias SELECT * por UPDATE ... SET.

Diez segundos que evitan una restauración de respaldo.

La sentencia UPDATE

UPDATE pacientes
SET telefono = '76980510'
WHERE id = 3;

Para varias columnas a la vez, separadas por comas:

UPDATE pacientes
SET telefono = '76980510',
    correo = 'ana.torres@correo.com'
WHERE id = 1;

Actualizar con cálculos

El valor nuevo puede depender del actual:

-- Subir un 10 % el costo de las citas programadas
UPDATE citas
SET costo = costo * 1.10
WHERE estado = 'programada';

Es mucho más eficiente que traer los registros, calcular en la aplicación y volver a guardarlos uno por uno.

Actualizar varias filas

UPDATE citas
SET estado = 'cancelada'
WHERE fecha < CURDATE() AND estado = 'programada';

Esa consulta cancela todas las citas programadas que ya pasaron. Aquí el WHERE afecta a varias filas a propósito, que es distinto de olvidarlo.

Actualizar con condiciones distintas por fila

CASE permite valores diferentes según la fila:

UPDATE doctores
SET telefono = CASE id
    WHEN 1 THEN '70011199'
    WHEN 2 THEN '70011288'
    WHEN 3 THEN '70011377'
    ELSE telefono
END
WHERE id IN (1, 2, 3);

Ese ELSE telefono es importante: sin él, cualquier fila que no coincida quedaría con NULL.

Limitar el número de filas

UPDATE citas
SET estado = 'cancelada'
WHERE estado = 'programada'
ORDER BY fecha
LIMIT 10;

Útil para procesar por lotes y no bloquear una tabla enorme durante minutos.

Saber cuántas filas cambiaron

MySQL informa después de cada sentencia:

Query OK, 3 rows affected

Si esperabas cambiar una fila y dice tres, algo salió mal. Lee siempre ese número.

Un detalle: si el valor nuevo es igual al que ya había, MySQL puede reportar 0 rows affected aunque el WHERE haya coincidido. No es un error.

La sentencia DELETE

DELETE FROM citas WHERE id = 6;

Las mismas reglas que UPDATE, con más motivo:

DELETE FROM citas;   -- borra TODAS las citas

DELETE con condiciones

DELETE FROM citas
WHERE estado = 'cancelada'
  AND fecha < '2025-01-01';

DELETE y las claves foráneas

Aquí se nota el trabajo que hicimos con las relaciones:

DELETE FROM pacientes WHERE id = 1;

Si ese paciente tiene citas y la clave foránea está en RESTRICT, MySQL rechaza el borrado. El error es incómodo la primera vez, pero te acaba de salvar de dejar citas huérfanas apuntando a un paciente inexistente.

Si la relación fuera CASCADE, se borrarían también las citas, en silencio. Por eso la decisión de ON DELETE importa tanto.

El borrado lógico

En sistemas reales, muchas veces no conviene borrar nada.

Piensa en un sistema médico: si eliminas un paciente, pierdes su historial. Si eliminas una factura, pierdes trazabilidad contable. Y a veces hay obligación legal de conservar los datos.

La alternativa es marcar el registro como inactivo:

ALTER TABLE pacientes ADD COLUMN eliminado_en TIMESTAMP NULL;

-- En lugar de borrar
UPDATE pacientes SET eliminado_en = NOW() WHERE id = 1;

-- Y al consultar
SELECT * FROM pacientes WHERE eliminado_en IS NULL;

Ventajas: conservas el historial, puedes revertir un borrado accidental y mantienes la integridad de todo lo relacionado.

El costo: todas tus consultas tienen que recordar filtrar. Por eso los frameworks lo automatizan —en Laravel se llama soft delete—, pero el mecanismo es exactamente este.

DELETE, TRUNCATE y DROP

Tres formas de quitar datos que se confunden:

Sentencia	Qué hace	Reversible en transacción
DELETE FROM t WHERE...	Borra filas concretas	Sí
TRUNCATE TABLE t	Vacía la tabla y reinicia el contador	No
DROP TABLE t	Elimina la tabla entera	No

TRUNCATE es mucho más rápido que DELETE FROM sin condiciones, porque no borra fila por fila. Pero no se puede deshacer y no funciona si hay claves foráneas apuntando a esa tabla.

El modo seguro de MySQL Workbench

Workbench viene con una protección activada por defecto que conviene conocer:

Error Code: 1175. You are using safe update mode

Ese error aparece cuando intentas un UPDATE o DELETE sin WHERE sobre la clave primaria. Es una red de seguridad.

Mucha gente lo desactiva de inmediato para «que funcione». Mi consejo: déjalo activado. Cuando aparezca, es señal de que revises tu sentencia. Y si de verdad quieres afectar a toda la tabla, añade un WHERE explícito:

UPDATE citas SET estado = 'cancelada' WHERE id > 0;

Si aun así necesitas desactivarlo:

SET SQL_SAFE_UPDATES = 0;
-- tu sentencia
SET SQL_SAFE_UPDATES = 1;

Vuelve a activarlo al terminar.

Transacciones: la red de seguridad real

Para operaciones importantes, envuélvelas en una transacción:

START TRANSACTION;

UPDATE citas SET estado = 'cancelada' WHERE fecha < CURDATE();

-- Revisa el resultado antes de confirmar
SELECT COUNT(*) FROM citas WHERE estado = 'cancelada';

-- Si todo está bien:
COMMIT;

-- Si algo salió mal:
ROLLBACK;

ROLLBACK deshace todo lo hecho desde el START TRANSACTION. Es la única forma de revertir un UPDATE mal hecho sin recurrir a un respaldo.

Requiere InnoDB, que es otra razón por la que insistimos en ese motor.

Antes de tocar producción

Una lista corta que vale la pena seguir:

1. Respaldo reciente, comprobado.
2. Ejecuta el SELECT equivalente y revisa las filas.
3. Envuélvelo en una transacción.
4. Comprueba el número de filas afectadas.
5. COMMIT solo si el número coincide con lo esperado.

Errores comunes

• Olvidar el WHERE. El error más caro de todos.
• Desactivar el modo seguro por costumbre.
• No revisar las filas afectadas.
• Borrar en vez de marcar como inactivo cuando hacía falta el historial.
• Confundir TRUNCATE con DELETE y perder la posibilidad de revertir.
• Ejecutar en producción sin respaldo.

Para cerrar

UPDATE y DELETE son sentencias sencillas de escribir y difíciles de deshacer. Los dos hábitos que quiero que te lleves: probar con SELECT antes, y usar transacciones cuando la operación importe.

En la siguiente lección juntamos las tres sentencias en un caso práctico completo.

Saludos y éxitos.