Tutorial SQL: Actualización de datos: UPDATE

Estructura de UPDATE

La sentencia UPDATE es una de las operaciones fundamentales en SQL que permite modificar datos existentes en una tabla. Esta operación forma parte del grupo de comandos DML (Data Manipulation Language) junto con INSERT y DELETE, que ya hemos visto en lecciones anteriores.

La estructura básica de una sentencia UPDATE sigue un patrón claro y lógico que nos permite especificar qué tabla queremos modificar, qué columnas y valores queremos actualizar, y opcionalmente, qué filas específicas deben ser afectadas por la actualización.

Sintaxis básica

La sintaxis estándar de una sentencia UPDATE es la siguiente:

UPDATE nombre_tabla
SET columna1 = valor1, columna2 = valor2, ...
WHERE condición;

Vamos a analizar cada parte de esta estructura:

• UPDATE: La palabra clave que indica que vamos a realizar una operación de actualización.
• nombre_tabla: El nombre de la tabla cuyos datos queremos modificar.
• SET: Palabra clave que precede a la lista de columnas y sus nuevos valores.
• columna = valor: Pares que especifican qué columna modificar y cuál será su nuevo valor.
• WHERE: Cláusula opcional que determina qué filas serán actualizadas.

La cláusula WHERE

La cláusula WHERE es crucial en las operaciones UPDATE, ya que determina qué registros serán modificados. Si omitimos esta cláusula, la actualización afectará a todas las filas de la tabla, lo que puede ser peligroso si no es nuestra intención.

-- Actualiza el precio de un producto específico
UPDATE productos
SET precio = 24.99
WHERE id_producto = 101;

En este ejemplo, solo se actualizará el precio del producto cuyo id_producto es 101. Sin la cláusula WHERE, todos los productos tendrían su precio cambiado a 24.99.

Actualización de múltiples columnas

Podemos actualizar varias columnas en una misma operación UPDATE, separando cada par columna-valor con comas:

UPDATE empleados
SET salario = 35000, departamento = 'Ventas'
WHERE id_empleado = 1001;

Este comando actualiza tanto el salario como el departamento del empleado con id 1001.

Uso de expresiones y funciones

El valor asignado a una columna puede ser una expresión que incluya operadores aritméticos, funciones o incluso referencias a otras columnas:

-- Aumentar el precio de todos los productos en un 10%
UPDATE productos
SET precio = precio * 1.10;

-- Actualizar la fecha de modificación al momento actual
UPDATE articulos
SET fecha_modificacion = CURRENT_TIMESTAMP
WHERE id_articulo = 205;

En el primer ejemplo, utilizamos el valor actual de la columna precio para calcular el nuevo valor. En el segundo, usamos la función CURRENT_TIMESTAMP para obtener la fecha y hora actuales.

Actualización con subconsultas

También podemos utilizar subconsultas (subqueries) dentro de una sentencia UPDATE, tanto en la cláusula SET como en la cláusula WHERE:

-- Actualizar el stock de productos basado en otra tabla
UPDATE productos p
SET stock = stock - (
    SELECT cantidad 
    FROM pedidos 
    WHERE id_producto = p.id_producto AND estado = 'Enviado'
)
WHERE EXISTS (
    SELECT 1 
    FROM pedidos 
    WHERE id_producto = p.id_producto AND estado = 'Enviado'
);

Este ejemplo más complejo actualiza el stock de productos restando las cantidades que ya han sido enviadas según la tabla de pedidos.

Limitaciones y consideraciones

Al trabajar con UPDATE, debemos tener en cuenta algunas consideraciones importantes:

• Restricciones de integridad: Las actualizaciones deben respetar las restricciones de la tabla (como claves foráneas, valores únicos, etc.).

-- Esto fallará si el departamento 'Marketing' no existe en la tabla departamentos
UPDATE empleados
SET id_departamento = (SELECT id FROM departamentos WHERE nombre = 'Marketing')
WHERE id_empleado = 1002;

• Tipos de datos: Los nuevos valores deben ser compatibles con los tipos de datos de las columnas.

-- Esto fallará si 'nombre' es una columna de tipo VARCHAR
UPDATE productos
SET nombre = 123
WHERE id_producto = 101;

• Transacciones: Es recomendable usar transacciones para operaciones UPDATE críticas, especialmente cuando afectan a muchas filas.

BEGIN TRANSACTION;

UPDATE cuentas
SET saldo = saldo - 1000
WHERE id_cuenta = 5001;

UPDATE cuentas
SET saldo = saldo + 1000
WHERE id_cuenta = 5002;

COMMIT;

Verificación previa con SELECT

Una buena práctica antes de ejecutar un UPDATE, especialmente en entornos de producción, es verificar qué registros serán afectados utilizando un SELECT con la misma condición WHERE:

-- Primero verificamos qué registros serán afectados
SELECT * FROM clientes WHERE region = 'Norte';

-- Si los resultados son los esperados, procedemos con el UPDATE
UPDATE clientes
SET categoria = 'Premium'
WHERE region = 'Norte';

Esta práctica nos ayuda a evitar actualizaciones no deseadas y a tener mayor control sobre nuestras operaciones.

Diferencias entre MySQL y PostgreSQL

Aunque la sintaxis básica de UPDATE es similar en MySQL y PostgreSQL, existen algunas diferencias sutiles:

• Sintaxis de LIMIT: MySQL permite limitar el número de filas afectadas con LIMIT, mientras que PostgreSQL utiliza una sintaxis diferente.

-- MySQL: limitar a 10 filas
UPDATE productos
SET descuento = 0.15
WHERE categoria = 'Electrónica'
LIMIT 10;

-- PostgreSQL: usar LIMIT en una subconsulta
UPDATE productos
SET descuento = 0.15
WHERE id IN (
    SELECT id 
    FROM productos 
    WHERE categoria = 'Electrónica' 
    LIMIT 10
);

• Alias de tablas: PostgreSQL tiene una sintaxis más flexible para los alias de tablas en operaciones UPDATE.

-- PostgreSQL permite esta sintaxis
UPDATE productos AS p
SET stock = p.stock - o.cantidad
FROM ordenes AS o
WHERE p.id_producto = o.id_producto;

Actualización múltiple

La actualización múltiple en SQL permite modificar datos en varias filas o incluso en múltiples tablas con una sola sentencia UPDATE. Esta técnica es especialmente útil cuando necesitamos realizar cambios masivos en nuestros datos de manera eficiente.

Actualización de múltiples filas

Una de las ventajas más importantes de SQL es la capacidad de actualizar múltiples registros simultáneamente. A diferencia de los lenguajes de programación tradicionales, donde tendríamos que iterar sobre cada registro, SQL nos permite modificar muchas filas con una sola instrucción.

-- Aumentar el salario en un 5% a todos los empleados del departamento de Tecnología
UPDATE empleados
SET salario = salario * 1.05
WHERE departamento = 'Tecnología';

Este comando actualizará el salario de todos los empleados que pertenezcan al departamento de Tecnología, sin importar cuántos sean. La eficiencia de esta operación es significativamente mayor que actualizar cada registro individualmente.

Actualización basada en condiciones complejas

Podemos crear condiciones más elaboradas para seleccionar exactamente qué registros queremos actualizar:

-- Aplicar descuento a productos que tienen bajo movimiento y alto stock
UPDATE productos
SET precio = precio * 0.85, en_oferta = TRUE
WHERE fecha_ultima_venta < (CURRENT_DATE - INTERVAL '90 days')
AND stock > 50
AND categoria IN ('Hogar', 'Jardín');

En este ejemplo, aplicamos un descuento del 15% y marcamos como oferta solo aquellos productos que cumplen múltiples condiciones: no se han vendido en los últimos 90 días, tienen más de 50 unidades en stock y pertenecen a ciertas categorías.

Actualización con CASE

La expresión CASE nos permite realizar actualizaciones condicionales, aplicando diferentes valores según distintas condiciones:

UPDATE productos
SET precio_final = 
    CASE 
        WHEN categoria = 'Electrónica' THEN precio * 0.90
        WHEN categoria = 'Ropa' THEN precio * 0.75
        WHEN categoria = 'Alimentos' THEN precio * 0.95
        ELSE precio
    END;

Este ejemplo aplica diferentes porcentajes de descuento según la categoría del producto. Los productos de electrónica reciben un 10% de descuento, los de ropa un 25%, y los alimentos un 5%. Para el resto de categorías, el precio se mantiene igual.

Actualización con JOIN en PostgreSQL

PostgreSQL permite actualizar datos basándose en información de otras tablas mediante la cláusula FROM:

UPDATE clientes c
SET nivel_fidelidad = 'Premium'
FROM compras cp
WHERE c.id_cliente = cp.id_cliente
AND cp.monto_total > 5000
AND cp.fecha_compra > (CURRENT_DATE - INTERVAL '1 year');

Este comando actualiza el nivel de fidelidad de los clientes a 'Premium' si han realizado compras por más de 5000 en el último año. La actualización se basa en datos de la tabla compras, relacionada con clientes.

Actualización con JOIN en MySQL

MySQL utiliza una sintaxis diferente para actualizar datos basándose en múltiples tablas:

UPDATE productos p
JOIN inventario i ON p.id_producto = i.id_producto
SET p.disponible = FALSE
WHERE i.cantidad = 0;

Este ejemplo marca como no disponibles todos los productos cuya cantidad en inventario sea cero.

Actualización con subconsultas correlacionadas

Las subconsultas correlacionadas son otra forma poderosa de realizar actualizaciones múltiples basadas en datos de otras tablas:

UPDATE empleados e
SET salario = salario * 1.10
WHERE departamento = 'Ventas'
AND EXISTS (
    SELECT 1 
    FROM ventas v 
    WHERE v.id_empleado = e.id_empleado
    AND v.fecha_venta > (CURRENT_DATE - INTERVAL '3 months')
    GROUP BY v.id_empleado
    HAVING SUM(v.monto) > 50000
);

Este comando aumenta en un 10% el salario de los empleados del departamento de Ventas que hayan generado más de 50,000 en ventas durante los últimos tres meses.

Actualización con valores de agregación

Podemos actualizar registros basándonos en resultados de funciones de agregación:

-- Actualizar el precio promedio por categoría
UPDATE productos p
SET precio_promedio_categoria = (
    SELECT AVG(precio)
    FROM productos
    WHERE categoria = p.categoria
);

Este ejemplo calcula el precio promedio para cada categoría y actualiza esa información en cada producto.

Actualización con tablas temporales

Para actualizaciones complejas, a veces es útil crear tablas temporales intermedias:

-- Crear tabla temporal con los productos a actualizar
CREATE TEMPORARY TABLE productos_a_actualizar AS
SELECT id_producto, precio * 0.80 AS nuevo_precio
FROM productos
WHERE stock > 100 AND fecha_creacion < '2023-01-01';

-- Realizar la actualización basada en la tabla temporal
UPDATE productos p
SET precio = t.nuevo_precio
FROM productos_a_actualizar t
WHERE p.id_producto = t.id_producto;

-- Eliminar la tabla temporal
DROP TABLE productos_a_actualizar;

Esta técnica es especialmente útil cuando la lógica para determinar qué registros actualizar y con qué valores es compleja.

Consideraciones de rendimiento

Al realizar actualizaciones múltiples, debemos tener en cuenta el rendimiento:

• Índices: Asegúrate de que las columnas en la cláusula WHERE estén indexadas para mejorar la velocidad.
• Transacciones: Usa transacciones para actualizaciones grandes, permitiendo rollback en caso de error.
• Bloqueos: Ten en cuenta que las actualizaciones masivas pueden bloquear tablas durante períodos prolongados.

-- Actualización por lotes para minimizar bloqueos
BEGIN TRANSACTION;

UPDATE productos
SET precio = precio * 1.05
WHERE id_producto BETWEEN 1 AND 1000;

COMMIT;

BEGIN TRANSACTION;

UPDATE productos
SET precio = precio * 1.05
WHERE id_producto BETWEEN 1001 AND 2000;

COMMIT;

Esta técnica de actualización por lotes puede reducir el tiempo de bloqueo de la tabla completa.

Actualización con RETURNING en PostgreSQL

PostgreSQL ofrece la cláusula RETURNING, que permite ver qué registros fueron modificados:

UPDATE clientes
SET puntos = puntos + 100
WHERE fecha_ultima_compra > (CURRENT_DATE - INTERVAL '30 days')
RETURNING id_cliente, nombre, puntos;

Esta sentencia no solo actualiza los puntos de los clientes que han comprado en los últimos 30 días, sino que también devuelve información sobre los registros actualizados, lo que puede ser útil para verificación o procesamiento adicional.