MaxCompute:Tabla PK - Actualizar datos en columnas específicas

Funcionamiento

El comportamiento de las columnas no especificadas depende de la operación:

Esta distinción es el comportamiento más importante que debe comprender: INSERT rellena las columnas faltantes con NULL, mientras que UPDATE y WHEN MATCHED las dejan intactas.

Casos de uso

El caso de uso más común es la construcción de tablas anchas a partir de un esquema de estrella. Cuando varias tablas de origen comparten la misma clave principal, escriba las columnas de cada tabla de origen en la tabla ancha de forma independiente y paralela. Al momento de la lectura, MaxCompute fusiona las filas por clave principal y devuelve registros completos. En comparación con la escritura de todas las columnas en una sola operación, este enfoque mejora el rendimiento de lectura y escritura, además de reducir los costos de almacenamiento.

Requisitos previos

Antes de empezar, asegúrese de contar con lo siguiente:

• Una tabla Delta con la actualización parcial de columnas habilitada (consulte Create a Delta table)

• Familiaridad con las instrucciones DML de MaxCompute: INSERT INTO, UPDATE, DELETE y MERGE INTO

Crear una tabla Delta

Para habilitar la actualización parcial de columnas, establezca dos propiedades de tabla al crearla:

CREATE TABLE delta_target
(
    key  BIGINT NOT NULL PRIMARY KEY,
    b    STRING,
    c    BIGINT
)
TBLPROPERTIES (
    "acid.partial.fields.update.enable" = "true",
    "transactional" = "true"
);

Tanto acid.partial.fields.update.enable como transactional deben establecerse en "true". Se admiten tanto tablas particionadas como no particionadas.

Insertar datos en columnas específicas

Utilice INSERT INTO para escribir valores en un subconjunto de columnas. Las columnas que no aparecen en la lista se establecen en NULL. Si inserta una fila con una clave principal que ya existe, MaxCompute actualiza solo las columnas especificadas y deja el resto sin cambios; esto funciona como una actualización parcial mediante inserción.

Ejemplo 1: Insertar una nueva fila y omitir la columna c

La columna c no está en la lista, por lo que se establece en NULL.

INSERT INTO TABLE delta_target(key, b) VALUES(1, '1');

SELECT * FROM delta_target;

Resultado:

+------------+------------+------------+
| key        | b          | c          |
+------------+------------+------------+
| 1          | 1          | NULL       |
+------------+------------+------------+

Ejemplo 2: Insertar una fila con clave principal duplicada para actualizar una columna específica

Ya existe una fila con key=1. La inserción con la misma clave principal actualiza la columna especificada (c) y deja la columna no especificada (b) sin cambios.

INSERT INTO TABLE delta_target(key, c) VALUES(1, 1);

SELECT * FROM delta_target;

Resultado:

+------------+------------+------------+
| key        | b          | c          |
+------------+------------+------------+
| 1          | 1          | 1          |
+------------+------------+------------+

Ejemplo 3: Actualizar otra columna manteniendo c sin cambios

La columna c no está en la lista, por lo que conserva su valor actual de 1.

INSERT INTO TABLE delta_target(key, b) VALUES(1, '11');

SELECT * FROM delta_target;

Resultado:

+------------+------------+------------+
| key        | b          | c          |
+------------+------------+------------+
| 1          | 11         | 1          |
+------------+------------+------------+

Ejemplo 4: Insertar una fila con una nueva clave principal

Si la clave principal no existe previamente, se inserta una nueva fila.

INSERT INTO TABLE delta_target VALUES(2, '2', 2);

SELECT * FROM delta_target;

Resultado:

+------------+------------+------------+
| key        | b          | c          |
+------------+------------+------------+
| 2          | 2          | 2          |
| 1          | 11         | 1          |
+------------+------------+------------+

Para obtener más información, consulte Insertar datos en una tabla o partición estática, o sobrescribirlos (INSERT INTO e INSERT OVERWRITE).

Actualizar columnas específicas en filas existentes

Utilice UPDATE para modificar columnas específicas en las filas coincidentes. Las columnas que no aparecen en la cláusula SET permanecen sin cambios.

Ejemplo 1: Actualizar la columna b para key=1 y dejar c sin cambios

UPDATE delta_target SET b='111' WHERE key=1;

SELECT * FROM delta_target;

Resultado:

+------------+------------+------------+
| key        | b          | c          |
+------------+------------+------------+
| 2          | 2          | 2          |
| 1          | 111        | 1          |
+------------+------------+------------+

Ejemplo 2: Actualizar la columna b para key=2 y dejar c sin cambios

UPDATE delta_target SET b='222' WHERE key=2;

SELECT * FROM delta_target;

Resultado:

+------------+------------+------------+
| key        | b          | c          |
+------------+------------+------------+
| 2          | 222        | 2          |
| 1          | 111        | 1          |
+------------+------------+------------+

Para obtener más información, consulte UPDATE y DELETE.

Fusionar datos de origen en columnas específicas

Utilice MERGE INTO para insertar o actualizar datos dirigiéndose solo a columnas específicas. En la cláusula WHEN MATCHED, solo se actualizan las columnas listadas; las demás permanecen sin cambios. En la cláusula WHEN NOT MATCHED, las columnas no listadas se establecen en NULL.

El siguiente ejemplo crea una tabla de origen y la fusiona con delta_target. La fusión actualiza la columna b para las filas coincidentes e inserta (key, b) para las filas nuevas; la columna c no se escribe en ninguno de los dos casos.

-- Create a source table with six rows
CREATE TABLE acid2_dml_pu_source AS
SELECT key, b, c
FROM VALUES
    (1, '10', 10),
    (2, '20', 20),
    (3, '30', 30),
    (4, '40', 40),
    (5, '50', 50),
    (6, '60', 60) t (key, b, c);

-- Merge: update b for matching rows, insert (key, b) for new rows
MERGE INTO delta_target AS t
USING acid2_dml_pu_source AS s ON s.key = t.key
WHEN MATCHED THEN
    UPDATE SET t.b = s.b
WHEN NOT MATCHED THEN
    INSERT (key, b) VALUES(s.key, s.b);

Resultado:

+------------+------------+------------+
| key        | b          | c          |
+------------+------------+------------+
| 3          | 30         | NULL       |
| 4          | 40         | NULL       |
| 5          | 50         | NULL       |
| 6          | 60         | NULL       |
| 2          | 20         | 2          |
| 1          | 10         | 1          |
+------------+------------+------------+

Las filas 3 a 6 son inserciones nuevas: la columna c es NULL porque no se especificó. Las filas 1 y 2 coincidieron: la columna b se actualizó y c conservó su valor anterior.

Para obtener más información, consulte MERGE INTO.

Pasos siguientes

• INSERT INTO e INSERT OVERWRITE

• UPDATE y DELETE

• MERGE INTO