MaxCompute:Mise à jour des données dans des colonnes spécifiques

Fonctionnement

Le comportement des colonnes non spécifiées dépend de l'opération :

Il est essentiel de bien comprendre cette distinction : l'instruction INSERT remplit les colonnes manquantes par la valeur NULL, tandis que les instructions UPDATE et WHEN MATCHED les laissent intactes.

Cas d'utilisation

Le cas d'utilisation le plus courant consiste à construire des tables larges à partir d'un schéma en étoile. Lorsque plusieurs tables source partagent la même clé primaire, écrivez les colonnes de chaque table source dans la table large de manière indépendante et parallèle. Au moment de la lecture, MaxCompute fusionne les lignes par clé primaire et renvoie des enregistrements complets. Par rapport à l'écriture de toutes les colonnes en une seule opération, cette approche améliore les performances en écriture et en lecture tout en réduisant les coûts de stockage.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Une table Delta avec la mise à jour partielle des colonnes activée (voir Créer une table Delta)

• Une bonne connaissance des instructions DML de MaxCompute : INSERT INTO, UPDATE, DELETE et MERGE INTO

Création d'une table Delta

Pour activer la mise à jour partielle des colonnes, définissez deux propriétés de table lors de sa création :

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

Les propriétés acid.partial.fields.update.enable et transactional doivent toutes deux être définies sur "true". Les tables partitionnées et non partitionnées sont prises en charge.

Insertion de données dans des colonnes spécifiques

Utilisez l'instruction INSERT INTO pour écrire des valeurs dans un sous-ensemble de colonnes. Les colonnes qui ne figurent pas dans la liste des colonnes sont définies sur NULL. Lorsque vous insérez une ligne dont la clé primaire existe déjà, MaxCompute met à jour uniquement les colonnes spécifiées et laisse les autres inchangées ; il s'agit effectivement d'une mise à jour partielle via une insertion.

Exemple 1 : Insertion d'une nouvelle ligne, en omettant la colonne c

La colonne c n'est pas répertoriée, elle est donc définie sur NULL.

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

SELECT * FROM delta_target;

Résultat :

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

Exemple 2 : Insertion d'une ligne avec une clé primaire en double pour mettre à jour une colonne spécifique

Une ligne avec key=1 existe déjà. L'insertion avec la même clé primaire met à jour la colonne spécifiée (c) et laisse la colonne non spécifiée (b) inchangée.

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

SELECT * FROM delta_target;

Résultat :

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

Exemple 3 : Mise à jour d'une autre colonne tout en conservant c inchangée

La colonne c n'est pas répertoriée, elle conserve donc sa valeur actuelle de 1.

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

SELECT * FROM delta_target;

Résultat :

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

Exemple 4 : Insertion d'une ligne avec une nouvelle clé primaire

Lorsque la clé primaire n'existe pas encore, une nouvelle ligne est insérée.

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

SELECT * FROM delta_target;

Résultat :

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

Pour plus d'informations, consultez la rubrique Insérer des données dans ou remplacer les données d'une table ou d'une partition statique (INSERT INTO et INSERT OVERWRITE).

Mise à jour de colonnes spécifiques dans des lignes existantes

Utilisez l'instruction UPDATE pour modifier des colonnes spécifiques dans les lignes correspondantes. Les colonnes qui ne figurent pas dans la clause SET sont laissées inchangées.

Exemple 1 : Mise à jour de la colonne b pour key=1, en laissant c inchangée

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

SELECT * FROM delta_target;

Résultat :

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

Exemple 2 : Mise à jour de la colonne b pour key=2, en laissant c inchangée

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

SELECT * FROM delta_target;

Résultat :

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

Pour plus d'informations, consultez la rubrique UPDATE et DELETE.

Fusion des données source dans des colonnes spécifiques

Utilisez l'instruction MERGE INTO pour effectuer des opérations d'upsert en ciblant uniquement des colonnes spécifiques. Dans la clause WHEN MATCHED, seules les colonnes répertoriées sont mises à jour ; les autres sont laissées inchangées. Dans la clause WHEN NOT MATCHED, les colonnes non répertoriées sont définies sur NULL.

L'exemple suivant crée une table source et la fusionne dans delta_target. La fusion met à jour la colonne b pour les lignes correspondantes et insère (key, b) pour les nouvelles lignes ; la colonne c n'est écrite dans aucun des deux cas.

-- 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);

Résultat :

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

Les lignes 3 à 6 sont de nouvelles insertions : la colonne c est NULL car elle n'a pas été spécifiée. Les lignes 1 et 2 ont été mises en correspondance : la colonne b a été mise à jour et c a conservé sa valeur précédente.

Pour plus d'informations, consultez la rubrique MERGE INTO.

Étapes suivantes

• INSERT INTO et INSERT OVERWRITE

• UPDATE et DELETE

• MERGE INTO