Tous les produits
Search

Ce produit

    MaxCompute:UPDATE

    Centre de documentation

    MaxCompute:UPDATE

    Dernière mise à jour :Aug 10, 2026

    L'instruction UPDATE modifie les valeurs des colonnes dans une ou plusieurs lignes d'une table transactionnelle (Transactional table) ou d'une table Delta.

    Prérequis

    Avant d'exécuter une instruction DELETE ou UPDATE, assurez-vous de disposer des éléments suivants :

    • Des autorisations de sélection et de mise à jour sur la table transactionnelle ou la table Delta cible

    Pour plus d'informations, consultez la page Autorisations MaxCompute.

    Limites

    • Les instructions UPDATE et DELETE fonctionnent uniquement avec les tables transactionnelles et les tables Delta. Pour obtenir des détails sur la configuration, consultez la page Paramètres pour les tables transactionnelles et les tables Delta.

    • L'instruction UPDATE appliquée à une table Delta ne peut pas modifier les colonnes de clé primaire (PK).

    Syntaxe

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

    Paramètres

    Paramètres obligatoires

    Paramètre

    Description

    table_name

    Nom de la table transactionnelle ou de la table Delta à mettre à jour.

    col1_name, col2_name

    Colonnes à mettre à jour. Au moins une colonne est requise.

    value1, value2

    Nouvelles valeurs pour les colonnes spécifiées. Au moins une valeur est requise.

    Paramètres facultatifs

    Paramètre

    Description

    Valeur par défaut

    alias

    Alias pour la table cible.

    Aucun alias

    where_condition

    Expression de filtre qui sélectionne les lignes à mettre à jour. Consultez la page Syntaxe SELECT pour connaître les expressions prises en charge.

    Toutes les lignes de la table sont mises à jour si ce paramètre est omis.

    additional_tables

    Une ou plusieurs tables source pour une mise à jour par jointure, spécifiées dans une clause FROM.

    Aucune jointure

    Clause FROM

    La clause FROM permet de mettre à jour les lignes de la table cible en se basant sur les lignes correspondantes d'une ou plusieurs tables source. Cette approche simplifie les mises à jour par jointure par rapport à la syntaxe basée sur les sous-requêtes.

    Le tableau suivant présente la même mise à jour par jointure écrite avec et sans clause FROM.

    Méthode

    Exemple

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

    Avec clause 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 version utilisant la clause FROM est plus concise et plus lisible. La version avec sous-requête nécessite à la fois une condition WHERE supplémentaire (pour les mises à jour limitées à l'intersection) et une agrégation dans la sous-requête (afin de garantir que la source produit une seule valeur par ligne cible).

    Lignes avec jointures multiples

    Une ligne avec jointure multiple se produit lorsqu'une ligne cible correspond à plusieurs lignes de la table source lors d'une mise à jour par jointure. Le résultat est alors non déterministe : MaxCompute utilise l'une des lignes source correspondantes pour effectuer la mise à jour, sans garantir laquelle sera sélectionnée.

    Pour éviter les mises à jour non déterministes, utilisez une agrégation dans une sous-requête afin de garantir que chaque ligne cible corresponde à exactement une valeur source :

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

    Remarques sur l'utilisation

    Choisissez l'opération adaptée à votre charge de travail

    Scénario

    Opération recommandée

    Petit nombre de lignes à mettre à jour ; les mises à jour et les lectures suivantes sont peu fréquentes

    UPDATE ou DELETE

    Plus de 5 % des lignes à mettre à jour occasionnellement ; les lectures suivantes sont fréquentes

    INSERT OVERWRITE ou INSERT INTO

    Par exemple, si un pipeline supprime ou met à jour 10 % des lignes d'une table dix fois par jour, comparez le coût total et la dégradation des performances de lecture des opérations DELETE / UPDATE répétées par rapport à l'utilisation de INSERT OVERWRITE pour chaque exécution, puis choisissez l'approche la plus efficace pour votre charge de travail. Consultez la page Insérer ou écraser des données (INSERT INTO \| INSERT OVERWRITE).

    Effectuez des mises à jour par lots, et non ligne par ligne

    MaxCompute exécute chaque instruction UPDATE sous forme de processus par lot. Chaque instruction consomme des ressources et entraîne des frais basés sur la quantité de données analysées, quel que soit le nombre de lignes modifiées. La soumission de nombreuses instructions au niveau de la ligne — par exemple, à partir d'un script Python qui génère une instruction UPDATE par ligne — accumule des coûts élevés et réduit l'efficacité.

    Consolidez les mises à jour en une seule instruction dans la mesure du possible :

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

    Impact sur le stockage des instructions DELETE et UPDATE

    La suppression ou la mise à jour de lignes génère des fichiers Delta plutôt que de réduire immédiatement le stockage. Pour récupérer de l'espace de stockage après plusieurs opérations, fusionnez les fichiers de base et les fichiers Delta de la table. Consultez la page Fusionner les fichiers des tables transactionnelles.

    Exemples

    Exemple 1 : Mettre à jour des lignes dans une table non partitionnée

    Créez une table transactionnelle, insérez des données et mettez à jour toutes les lignes où 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          |
-- +------------+

    Exemple 2 : Mettre à jour des lignes dans une table partitionnée

    Créez une table transactionnelle partitionnée, insérez des données dans la partition ds='2019' et mettez à jour les lignes de cette partition.

    -- 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       |
-- +------------+------------+

    Exemple 3 : Mettre à jour plusieurs colonnes à l'aide de quatre méthodes

    Cet exemple illustre quatre façons de mettre à jour plusieurs colonnes dans une table transactionnelle en effectuant une jointure avec une table source.

    -- 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       |
-- +------------+------------+------------+

    Exemple 4 : Mise à jour par jointure à l'aide de la clause FROM (deux tables)

    La clause FROM simplifie les mises à jour par jointure. Les deux instructions ci-dessous produisent le même résultat.

    -- 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        |
-- +------------+------------+------------+

    Exemple 5 : Mise à jour par jointure avec plusieurs tables source et conditions de filtrage

    Cet exemple effectue une jointure entre trois tables et applique des filtres aux tables source et cible. Seules les lignes satisfaisant toutes les conditions sont mises à jour.

    -- 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         |
-- +------------+------------+------------+

    Exemple 6 : Mettre à jour des lignes dans une table Delta

    Créez une table Delta, insérez des données et mettez à jour la colonne val pour une ligne spécifique à l'aide de deux méthodes équivalentes.

    -- 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 |
-- +------------+------------+----+----+

    Étapes suivantes

    • DELETE : Supprimer des lignes d'une table transactionnelle ou d'une table Delta.

    • ALTER TABLE : Fusionner les fichiers de base et les fichiers Delta pour réduire le stockage après plusieurs opérations de mise à jour ou de suppression.