Todos los productos
Search

Este producto

    MaxCompute:UPDATE

    Centro de documentos

    MaxCompute:UPDATE

    Última actualización: Sep 03, 2026

    La instrucción UPDATE modifica los valores de columna en una o más filas de una tabla transaccional o Delta Table.

    Requisitos previos

    Antes de ejecutar una instrucción DELETE o UPDATE, asegúrese de contar con:

    • Permisos de selección y actualización en la tabla transaccional o Delta Table de destino.

    Para obtener más información, consulte Permisos de MaxCompute.

    Limitaciones

    • Las instrucciones UPDATE y DELETE funcionan únicamente en tablas transaccionales y Delta Tables. Para detalles sobre la configuración, consulte Parámetros para Transaction Table y Delta Table.

    • La instrucción UPDATE en una Delta Table no puede modificar columnas de clave principal (PK).

    Sintaxis

    -- Method 1: Update individual columns
UPDATE <table_name> [[AS] alias] SET <col1_name> = <value1> [, <col2_name> = <value2> ...] [WHERE <where_condition>];

-- Method 2: Update multiple columns as a tuple
UPDATE <table_name> [[AS] alias] SET (<col1_name> [, <col2_name> ...]) = (<value1> [, <value2> ...]) [WHERE <where_condition>];

-- Method 3: Update with a FROM clause (join update)
UPDATE <table_name> [[AS] alias]
    SET <col1_name> = <value1> [, <col2_name> = <value2>, ...]
    [FROM <additional_tables>]
    [WHERE <where_condition>];

    Parámetros

    Parámetros obligatorios

    Parameter

    Description

    table_name

    Nombre de la tabla transaccional o Delta Table que se va a actualizar.

    col1_name, col2_name

    Columnas por actualizar. Se requiere como mínimo una columna.

    value1, value2

    Nuevos valores para las columnas especificadas. Se requiere como mínimo un valor.

    Parámetros opcionales

    Parameter

    Description

    Default

    alias

    Alias para la tabla de destino.

    Sin alias

    where_condition

    Expresión de filtro que selecciona las filas por actualizar. Consulte Sintaxis de SELECT para ver las expresiones compatibles.

    Si se omite, se actualizan todas las filas de la tabla.

    additional_tables

    Una o más tablas de origen para una actualización con unión, especificadas en una cláusula FROM.

    Sin unión

    Cláusula FROM

    La cláusula FROM permite actualizar filas en la tabla de destino con base en las coincidencias encontradas en una o más tablas de origen. Esto simplifica las actualizaciones con unión en comparación con la sintaxis basada en subconsultas.

    A continuación se muestra la misma actualización con unión escrita con y sin la cláusula FROM.

    Approach

    Example

    Sin cláusula FROM

    UPDATE target SET v = (SELECT MIN(v) FROM src GROUP BY k WHERE target.k = src.key) WHERE target.k IN (SELECT k FROM src);

    Con cláusula FROM

    UPDATE target SET v = b.v FROM (SELECT k, MIN(v) AS v FROM src GROUP BY k) b WHERE target.k = b.k;

    La versión con cláusula FROM es más breve y fácil de leer. La versión con subconsulta requiere tanto una condición WHERE adicional (para actualizaciones solo de intersección) como una agregación dentro de la subconsulta (para garantizar que el origen produzca un único valor por cada fila de destino).

    Filas con múltiples uniones

    Una fila con múltiples uniones ocurre cuando una fila de destino coincide con más de una fila en la tabla de origen durante una actualización con unión. El resultado es no determinista: MaxCompute utiliza una de las filas de origen coincidentes para realizar la actualización, pero no garantiza cuál de ellas.

    Para evitar actualizaciones no deterministas, utilice una agregación en una subconsulta y así asegurar que cada fila de destino se asigne exactamente a un valor de origen:

    -- Produces a unique value per key before joining
UPDATE target SET v = b.v
FROM (SELECT k, MIN(v) AS v FROM src GROUP BY k) b
WHERE target.k = b.k;

    Notas de uso

    Elija la operación adecuada para su carga de trabajo

    Scenario

    Recommended operation

    Pocas filas por actualizar; tanto las actualizaciones como las lecturas posteriores son poco frecuentes

    UPDATE o DELETE

    Más del 5 % de las filas por actualizar de forma esporádica; las lecturas posteriores son frecuentes

    INSERT OVERWRITE o INSERT INTO

    Por ejemplo, si un pipeline elimina o actualiza el 10 % de las filas de una tabla diez veces al día, compare el costo total y la degradación del rendimiento de lectura que implican las operaciones repetidas de DELETE/UPDATE frente al uso de INSERT OVERWRITE en cada ejecución. Después, elija el enfoque más eficiente para su carga de trabajo. Consulte Inserción o sobrescritura de datos (INSERT INTO \| INSERT OVERWRITE).

    Actualice en lotes, no fila por fila

    MaxCompute ejecuta cada instrucción UPDATE como un proceso por lotes. Cada instrucción consume recursos y genera costos según la cantidad de datos escaneados, sin importar cuántas filas se modifiquen. Enviar muchas instrucciones a nivel de fila —por ejemplo, desde un script de Python que genera una instrucción UPDATE por cada fila— acumula costos elevados y reduce la eficiencia.

    Consolide las actualizaciones en una sola instrucción siempre que sea posible:

    -- Recommended: one statement updates all matching rows
UPDATE table1 SET col1 = (SELECT value1 FROM table2 WHERE table1.id = table2.id AND table1.region = table2.region);
    -- Not recommended: one statement per row
UPDATE table1 SET col1 = 1 WHERE id = '2021063001' AND region = 'beijing';
UPDATE table1 SET col1 = 2 WHERE id = '2021063002' AND region = 'beijing';

    Impacto de DELETE y UPDATE en el almacenamiento

    Eliminar o actualizar filas genera archivos Delta en lugar de reducir el almacenamiento de inmediato. Para recuperar espacio después de múltiples operaciones, fusione los archivos base y los archivos Delta de la tabla. Consulte Fusión de archivos de tabla transaccional.

    Ejemplos

    Ejemplo 1: Actualización de filas en una tabla sin particiones

    Cree una tabla transaccional, inserte datos y actualice todas las filas donde id = 2.

    -- Create a Transactional table
CREATE TABLE IF NOT EXISTS acid_update(id BIGINT) tblproperties ("transactional"="true");

-- Insert data
INSERT OVERWRITE TABLE acid_update VALUES(1),(2),(3),(2);

-- Verify the inserted data
SELECT * FROM acid_update;
-- Result:
-- +------------+
-- | id         |
-- +------------+
-- | 1          |
-- | 2          |
-- | 3          |
-- | 2          |
-- +------------+

-- Update: set id to 4 for all rows where id is 2
UPDATE acid_update SET id = 4 WHERE id = 2;

-- Verify the result
SELECT * FROM acid_update;
-- Result: both rows with id=2 are updated to 4
-- +------------+
-- | id         |
-- +------------+
-- | 1          |
-- | 3          |
-- | 4          |
-- | 4          |
-- +------------+

    Ejemplo 2: Actualización de filas en una tabla con particiones

    Cree una tabla transaccional con particiones, inserte datos en la partición ds='2019' y actualice las filas de dicha partición.

    -- Create a partitioned Transactional table
CREATE TABLE IF NOT EXISTS acid_update_pt(id BIGINT) PARTITIONED BY(ds STRING) tblproperties ("transactional"="true");

-- Add a partition
ALTER TABLE acid_update_pt ADD IF NOT EXISTS PARTITION (ds='2019');

-- Insert data
INSERT OVERWRITE TABLE acid_update_pt PARTITION (ds='2019') VALUES(1),(2),(3);

-- Verify the inserted data
SELECT * FROM acid_update_pt WHERE ds = '2019';
-- Result:
-- +------------+------------+
-- | id         | ds         |
-- +------------+------------+
-- | 1          | 2019       |
-- | 2          | 2019       |
-- | 3          | 2019       |
-- +------------+------------+

-- Update: set id to 4 for the row where ds='2019' and id=2
UPDATE acid_update_pt SET id = 4 WHERE ds = '2019' AND id = 2;

-- Verify the result
SELECT * FROM acid_update_pt WHERE ds = '2019';
-- Result:
-- +------------+------------+
-- | id         | ds         |
-- +------------+------------+
-- | 4          | 2019       |
-- | 1          | 2019       |
-- | 3          | 2019       |
-- +------------+------------+

    Ejemplo 3: Actualización de varias columnas mediante cuatro métodos

    Este ejemplo demuestra cuatro formas de actualizar varias columnas en una tabla transaccional mediante una unión con una tabla de origen.

    -- Create the target Transactional table and a source table
CREATE TABLE IF NOT EXISTS acid_update_t(id INT, value1 INT, value2 INT) tblproperties ("transactional"="true");
CREATE TABLE IF NOT EXISTS acid_update_s(id INT, value1 INT, value2 INT);

-- Insert data
INSERT OVERWRITE TABLE acid_update_t VALUES(2,20,21),(3,30,31),(4,40,41);
INSERT OVERWRITE TABLE acid_update_s VALUES(1,100,101),(2,200,201),(3,300,301);

-- Method 1: Update with constant values (updates all rows)
UPDATE acid_update_t SET (value1, value2) = (60, 61);
SELECT * FROM acid_update_t;
-- Result:
-- +------------+------------+------------+
-- | id         | value1     | value2     |
-- +------------+------------+------------+
-- | 2          | 60         | 61         |
-- | 3          | 60         | 61         |
-- | 4          | 60         | 61         |
-- +------------+------------+------------+

-- Method 2: Join update (left join from acid_update_t to acid_update_s)
-- Rows in acid_update_t with no match in acid_update_s are set to NULL
UPDATE acid_update_t SET (value1, value2) = (SELECT value1, value2 FROM acid_update_s WHERE acid_update_t.id = acid_update_s.id);
SELECT * FROM acid_update_t;
-- Result:
-- +------------+------------+------------+
-- | id         | value1     | value2     |
-- +------------+------------+------------+
-- | 2          | 200        | 201        |
-- | 3          | 300        | 301        |
-- | 4          | NULL       | NULL       |
-- +------------+------------+------------+

-- Method 3: Join update restricted to the intersection (rows with a matching id in both tables)
UPDATE acid_update_t SET (value1, value2) = (SELECT value1, value2 FROM acid_update_s WHERE acid_update_t.id = acid_update_s.id) WHERE acid_update_t.id IN (SELECT id FROM acid_update_s);
SELECT * FROM acid_update_t;
-- Result: same as Method 2 because id=4 has no match and is unchanged from the Method 2 result
-- +------------+------------+------------+
-- | id         | value1     | value2     |
-- +------------+------------+------------+
-- | 2          | 200        | 201        |
-- | 3          | 300        | 301        |
-- | 4          | NULL       | NULL       |
-- +------------+------------+------------+

-- Method 4: Join update with aggregation (uses MAX to handle multiple matching source rows)
UPDATE acid_update_t SET (id, value1, value2) = (SELECT id, MAX(value1), MAX(value2) FROM acid_update_s WHERE acid_update_t.id = acid_update_s.id GROUP BY acid_update_s.id) WHERE acid_update_t.id IN (SELECT id FROM acid_update_s);
SELECT * FROM acid_update_t;
-- Result:
-- +------------+------------+------------+
-- | id         | value1     | value2     |
-- +------------+------------+------------+
-- | 2          | 200        | 201        |
-- | 3          | 300        | 301        |
-- | 4          | NULL       | NULL       |
-- +------------+------------+------------+

    Ejemplo 4: Actualización con unión mediante la cláusula FROM (dos tablas)

    La cláusula FROM simplifica las actualizaciones con unión. Ambas instrucciones siguientes producen el mismo resultado.

    -- Create the target and source tables
CREATE TABLE IF NOT EXISTS acid_update_t(id BIGINT, value1 BIGINT, value2 BIGINT) tblproperties ("transactional"="true");
CREATE TABLE IF NOT EXISTS acid_update_s(id BIGINT, value1 BIGINT, value2 BIGINT);

-- Insert data
INSERT OVERWRITE TABLE acid_update_t VALUES(2,20,21),(3,30,31),(4,40,41);
INSERT OVERWRITE TABLE acid_update_s VALUES(1,100,101),(2,200,201),(3,300,301);

-- Join update using the FROM clause
UPDATE acid_update_t SET value1 = b.value1, value2 = b.value2
FROM acid_update_s b WHERE acid_update_t.id = b.id;

-- Equivalent statement using a table alias for the target table
UPDATE acid_update_t a SET a.value1 = b.value1, a.value2 = b.value2
FROM acid_update_s b WHERE a.id = b.id;

-- Verify the result: rows with id=2 and id=3 are updated; id=4 has no match and is unchanged
SELECT * FROM acid_update_t;
-- Result:
-- +------------+------------+------------+
-- | id         | value1     | value2     |
-- +------------+------------+------------+
-- | 4          | 40         | 41         |
-- | 2          | 200        | 201        |
-- | 3          | 300        | 301        |
-- +------------+------------+------------+

    Ejemplo 5: Actualización con unión de varias tablas de origen y condiciones de filtro

    Este ejemplo une tres tablas y aplica filtros tanto a las tablas de origen como a la de destino. Solo se actualizan las filas que cumplen todas las condiciones.

    -- Create three tables
CREATE TABLE IF NOT EXISTS acid_update_t(id BIGINT, value1 BIGINT, value2 BIGINT) tblproperties ("transactional"="true");
CREATE TABLE IF NOT EXISTS acid_update_s(id BIGINT, value1 BIGINT, value2 BIGINT);
CREATE TABLE IF NOT EXISTS acid_update_m(id BIGINT, value1 BIGINT, value2 BIGINT);

-- Insert data
INSERT OVERWRITE TABLE acid_update_t VALUES(2,20,21),(3,30,31),(4,40,41),(5,50,51);
INSERT OVERWRITE TABLE acid_update_s VALUES(1,100,101),(2,200,201),(3,300,301),(4,400,401),(5,500,501);
INSERT OVERWRITE TABLE acid_update_m VALUES(3,30,101),(4,400,201),(5,300,301);

-- Join update: filter both the source and target tables in the WHERE clause
-- Only rows with id > 2 where neither the target's value1 nor the source's value1
-- appears in acid_update_m for the same id are updated
UPDATE acid_update_t
SET value1 = acid_update_s.value1, value2 = acid_update_s.value2
FROM acid_update_s
WHERE acid_update_t.id = acid_update_s.id
  AND acid_update_s.id > 2
  AND acid_update_t.value1 NOT IN (SELECT value1 FROM acid_update_m WHERE id = acid_update_t.id)
  AND acid_update_s.value1 NOT IN (SELECT value1 FROM acid_update_m WHERE id = acid_update_s.id);

-- Verify the result: only id=5 satisfies all conditions
SELECT * FROM acid_update_t;
-- Result:
-- +------------+------------+------------+
-- | id         | value1     | value2     |
-- +------------+------------+------------+
-- | 5          | 500        | 501        |
-- | 2          | 20         | 21         |
-- | 3          | 30         | 31         |
-- | 4          | 40         | 41         |
-- +------------+------------+------------+

    Ejemplo 6: Actualización de filas en una Delta Table

    Cree una Delta Table, inserte datos y actualice la columna val de una fila específica mediante dos métodos equivalentes.

    -- Create a Delta Table with a primary key
CREATE TABLE IF NOT EXISTS mf_dt (
    pk  BIGINT NOT NULL PRIMARY KEY,
    val BIGINT NOT NULL
)
PARTITIONED BY(dd STRING, hh STRING)
tblproperties ("transactional"="true");

-- Insert data
INSERT OVERWRITE TABLE mf_dt PARTITION (dd='01', hh='02')
VALUES (1, 1), (2, 2), (3, 3);

-- Verify the inserted data
SELECT * FROM mf_dt WHERE dd='01' AND hh='02';
-- Result:
-- +------------+------------+----+----+
-- | pk         | val        | dd | hh |
-- +------------+------------+----+----+
-- | 1          | 1          | 01 | 02 |
-- | 3          | 3          | 01 | 02 |
-- | 2          | 2          | 01 | 02 |
-- +------------+------------+----+----+

-- Method 1: Update with a direct value
UPDATE mf_dt SET val = 30 WHERE pk = 3 AND dd='01' AND hh='02';

-- Method 2: Update using a FROM clause with inline values
UPDATE mf_dt SET val = delta.val
FROM (SELECT pk, val FROM VALUES (3, 30) t (pk, val)) delta
WHERE delta.pk = mf_dt.pk AND mf_dt.dd='01' AND mf_dt.hh='02';

-- Verify the result
SELECT * FROM mf_dt WHERE dd='01' AND hh='02';
-- Result: val for pk=3 is updated from 3 to 30
-- +------------+------------+----+----+
-- | pk         | val        | dd | hh |
-- +------------+------------+----+----+
-- | 1          | 1          | 01 | 02 |
-- | 3          | 30         | 01 | 02 |
-- | 2          | 2          | 01 | 02 |
-- +------------+------------+----+----+

    Pasos siguientes

    • DELETE: Eliminación de filas de una tabla transaccional o Delta Table.

    • ALTER TABLE: Fusión de archivos base y archivos Delta para reducir el almacenamiento tras múltiples operaciones de actualización o eliminación.