Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # MERGE Fusionne de manière conditionnelle les lignes d’une table source dans une table cible. Traditionnellement, cela ne peut être réalisé qu’en utilisant plusieurs instructions d’insertion, de mise à jour ou de suppression séparément. Pour plus d’informations sur les opérations que MERGE vous permet de combiner, consultez [UPDATE](https://docs.aws.amazon.com/redshift/latest/dg/r_UPDATE.html), [DELETE](https://docs.aws.amazon.com/redshift/latest/dg/r_DELETE.html) et [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html). ## Syntaxe ``` MERGE INTO target_table USING source_table [ [ AS ] alias ] ON match_condition [ WHEN MATCHED THEN { UPDATE SET col_name = { expr } [,...] | DELETE } WHEN NOT MATCHED THEN INSERT [ ( col_name [,...] ) ] VALUES ( { expr } [, ...] ) | REMOVE DUPLICATES ] ``` ## Parameters *target\$1table* Table temporaire ou permanente dans laquelle l’instruction MERGE est fusionnée. *source\$1table* Table temporaire ou permanente fournissant les lignes à fusionner dans *target\$1table*. *source\$1table* peut également être une table Spectrum. *alias* Nom alternatif temporaire pour *source\$1table*. Ce paramètre est facultatif. L’*alias* précédent avec AS est également facultatif. *match\$1condition* Spécifie des prédicats égaux entre la colonne de la table source et la colonne de la table cible qui sont utilisés pour déterminer si les lignes de *source\$1table* peuvent correspondre aux lignes de *target\$1table*. Si la condition est remplie, MERGE exécute *matched\$1clause* pour cette ligne. Sinon, MERGE exécute *not\$1matched\$1clause* pour cette ligne. WHEN MATCHED Spécifie l’action à exécuter lorsque la condition de correspondance entre une ligne source et une ligne cible est évaluée sur True. Vous pouvez spécifier une action UPDATE ou une action DELETE. UPDATE Met à jour la ligne correspondante dans *target\$1table*. Seules les valeurs dans *col\$1name* que vous spécifiez sont mises à jour. DELETE Supprime la ligne correspondante dans *target\$1table*. WHEN NOT MATCHED Spécifie l’action à exécuter lorsque la condition de correspondance est évaluée sur False ou Unknown. Vous pouvez uniquement spécifier l’action d’insertion INSERT pour cette clause. INSERT Insère dans les lignes *target\$1table* à partir de *source\$1table* ne correspondant à aucune ligne dans *target\$1table*, en fonction de *match\$1condition*. *col\$1name* cible peut être répertorié dans n’importe quel ordre. Si vous ne fournissez aucune valeur *col\$1name*, l’ordre par défaut correspond à l’ordre déclaré de toutes les colonnes de la table. *col\$1name* Un ou plusieurs noms de colonnes que vous voulez modifier. N’incluez pas le nom de la table quand vous spécifiez la colonne cible. *expr* Expression définissant la nouvelle valeur pour *col\$1name*. REMOVE DUPLICATES Spécifie que la commande MERGE s’exécute en mode simplifié. Le mode simplifié a les exigences suivantes : + *target\$1table* et *source\$1table* doivent avoir le même nombre de colonnes, des types de colonnes compatibles et le même ordre de colonnes. + Omettez la clause WHEN et les clauses UPDATE et INSERT de votre commande MERGE. + Utilisez la clause REMOVE DUPLICATES dans votre commande MERGE. En mode simplifié, MERGE effectue les opérations suivantes : + Les lignes dans *target\$1table* qui ont une correspondance dans *source\$1table* sont mises à jour pour correspondre aux valeurs dans *source\$1table*. + Les lignes dans *source\$1table* qui n’ont pas de correspondance dans *target\$1table* sont insérées dans *target\$1table*. + Lorsque plusieurs lignes dans *target\$1table* correspondent à la même ligne dans *source\$1table*, les lignes dupliquées sont supprimées. Amazon Redshift conserve une ligne et la met à jour. Les lignes dupliquées qui ne correspondent pas à une ligne dans *source\$1table* restent inchangées. L’utilisation de REMOVE DUPLICATES donne de meilleures performances que l’utilisation de WHEN MATCHED et WHEN NOT MATCHED. Nous vous recommandons d’utiliser REMOVE DUPLICATES si *target\$1table* et *source\$1table* sont compatibles et si vous n’avez pas besoin de conserver les lignes dupliquées dans *target\$1table*. ## Notes d’utilisation + Pour exécuter des instructions MERGE, vous devez être propriétaire à la fois de *source\$1table* et de *target\$1table*, ou disposer de l’autorisation SELECT pour ces tables. En outre, vous devez disposer des autorisations UPDATE, DELETE et INSERT pour *target\$1table* en fonction des opérations incluses dans votre instruction MERGE. + *target\$1table* ne peut pas être une table système, une table de catalogue ou une table externe. + *source\$1table* et *target\$1table* ne peuvent pas être la même table. + Vous ne pouvez pas utiliser la clause WITH dans une instruction MERGE. + Les lignes de la *target\$1table* ne peuvent pas correspondre à plusieurs lignes de la *source\$1table*. Prenez l’exemple suivant : ``` CREATE TABLE target (id INT, name CHAR(10)); CREATE TABLE source (id INT, name CHAR(10)); INSERT INTO target VALUES (1, 'Bob'), (2, 'John'); INSERT INTO source VALUES (1, 'Tony'), (1, 'Alice'), (3, 'Bill'); MERGE INTO target USING source ON target.id = source.id WHEN MATCHED THEN UPDATE SET id = source.id, name = source.name WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name); ERROR: Found multiple matches to update the same tuple. MERGE INTO target USING source ON target.id = source.id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name); ERROR: Found multiple matches to update the same tuple. ``` Dans les deux instructions MERGE, l’opération échoue parce qu’il y a plusieurs lignes dans la table `source` avec une valeur ID de `1`. + *match\$1condition* et *expr* ne peuvent pas référencer partiellement les colonnes de type SUPER. Par exemple, si votre objet de type SUPER est un tableau ou une structure, vous ne pouvez pas utiliser des éléments individuels de cette colonne pour *match\$1condition* ou *expr*, mais vous pouvez utiliser la colonne entière. Prenez l’exemple suivant : ``` CREATE TABLE IF NOT EXISTS target (key INT, value SUPER); CREATE TABLE IF NOT EXISTS source (key INT, value SUPER); INSERT INTO target VALUES (1, JSON_PARSE('{"key": 88}')); INSERT INTO source VALUES (1, ARRAY(1, 'John')), (2, ARRAY(2, 'Bill')); MERGE INTO target USING source ON target.key = source.key WHEN matched THEN UPDATE SET value = source.value[0] WHEN NOT matched THEN INSERT VALUES (source.key, source.value[0]); ERROR: Partial reference of SUPER column is not supported in MERGE statement. ``` Pour plus d’informations sur le type SUPER, consultez [Type SUPER](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html). + Si *source\$1table* est volumineuse, définir les colonnes de jointure de *target\$1table* et de *source\$1table* comme clés de distribution peut améliorer les performances. + Pour utiliser la clause REMOVE DUPLICATES, vous devez disposer des autorisations SELECT, INSERT et DELETE pour *target\$1table*. + *source\$1table* peut être une vue ou une sous-requête. Voici un exemple d’instruction MERGE dans laquelle *source\$1table* est une sous-requête qui supprime les lignes dupliquées. ``` MERGE INTO target USING (SELECT id, name FROM source GROUP BY 1, 2) as my_source ON target.id = my_source.id WHEN MATCHED THEN UPDATE SET id = my_source.id, name = my_source.name WHEN NOT MATCHED THEN INSERT VALUES (my_source.id, my_source.name); ``` + La cible ne peut pas être la source de données d’une sous-requête de la même instruction MERGE. Par exemple, la commande SQL suivante renvoie une erreur du type ERROR : L'instruction Source view/subquery in Merge ne peut pas référencer la table cible. car la sous-requête fait référence `target` au lieu de. `source` ``` MERGE INTO target USING (SELECT id, name FROM target GROUP BY 1, 2) as my_source ON target.id = my_source.id WHEN MATCHED THEN UPDATE SET id = my_source.id, name = my_source.name WHEN NOT MATCHED THEN INSERT VALUES (my_source.id, my_source.name); ``` ## Exemples L’exemple suivant crée deux tables, puis exécute une opération MERGE sur celles-ci qui met à jour les lignes correspondantes dans la table cible et insère des lignes qui ne correspondent pas. Elle insère ensuite une autre valeur dans la table source et exécute une autre opération MERGE, qui supprime cette fois les lignes correspondantes et insère la nouvelle ligne de la table source. Créez et remplissez d’abord les tables source et cible. ``` CREATE TABLE target (id INT, name CHAR(10)); CREATE TABLE source (id INT, name CHAR(10)); INSERT INTO target VALUES (101, 'Bob'), (102, 'John'), (103, 'Susan'); INSERT INTO source VALUES (102, 'Tony'), (103, 'Alice'), (104, 'Bill'); SELECT * FROM target; id | name -----+------------ 101 | Bob 102 | John 103 | Susan (3 rows) SELECT * FROM source; id | name -----+------------ 102 | Tony 103 | Alice 104 | Bill (3 rows) ``` Fusionnez ensuite la table source dans la table cible, ce qui met à jour la table cible avec les lignes correspondantes et insère les lignes de la table source qui n’ont aucune correspondance. ``` MERGE INTO target USING source ON target.id = source.id WHEN MATCHED THEN UPDATE SET id = source.id, name = source.name WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name); SELECT * FROM target; id | name -----+------------ 101 | Bob 102 | Tony 103 | Alice 104 | Bill (4 rows) ``` Notez que les lignes dont les valeurs d’id sont 102 et 103 sont mises à jour pour correspondre aux valeurs de nom de la table cible. En outre, une nouvelle ligne avec une valeur d’id 104 et une valeur de nom Bill est insérée dans la table cible. Ensuite, insérez une nouvelle ligne dans la table source. ``` INSERT INTO source VALUES (105, 'David'); SELECT * FROM source; id | name -----+------------ 102 | Tony 103 | Alice 104 | Bill 105 | David (4 rows) ``` Enfin, exécutez une opération de fusion en supprimant les lignes correspondantes dans la table cible et en insérant les lignes qui ne correspondent pas. ``` MERGE INTO target USING source ON target.id = source.id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name); SELECT * FROM target; id | name -----+------------ 101 | Bob 105 | David (2 rows) ``` Les lignes avec les valeurs d’id 102, 103 et 104 sont supprimées de la table cible, et une nouvelle ligne avec une valeur d’id de 105 et la valeur de nom David est insérée dans la table cible. L’exemple suivant affiche la syntaxe simplifiée d’une commande MERGE utilisant la clause REMOVE DUPLICATES. ``` CREATE TABLE target (id INT, name CHAR(10)); CREATE TABLE source (id INT, name CHAR(10)); INSERT INTO target VALUES (30, 'Tony'), (11, 'Alice'), (23, 'Bill'); INSERT INTO source VALUES (23, 'David'), (22, 'Clarence'); MERGE INTO target USING source ON target.id = source.id REMOVE DUPLICATES; SELECT * FROM target; id | name ---+------------ 30 | Tony 11 | Alice 23 | David 22 | Clarence (4 rows) ``` L’exemple suivant affiche la syntaxe simplifiée d’une commande MERGE utilisant la clause REMOVE DUPLICATES, qui supprime les lignes dupliquées de *target\$1table* si elles ont des lignes correspondantes dans *source\$1table*. ``` CREATE TABLE target (id INT, name CHAR(10)); CREATE TABLE source (id INT, name CHAR(10)); INSERT INTO target VALUES (30, 'Tony'), (30, 'Daisy'), (11, 'Alice'), (23, 'Bill'), (23, 'Nikki'); INSERT INTO source VALUES (23, 'David'), (22, 'Clarence'); MERGE INTO target USING source ON target.id = source.id REMOVE DUPLICATES; SELECT * FROM target; id | name ---+------------ 30 | Tony 30 | Daisy 11 | Alice 23 | David 22 | Clarence (5 rows) ``` Après l’exécution de MERGE, il n’y a qu’une seule ligne avec une valeur d’ID 23 dans *target\$1table*. Comme aucune ligne n’avait la valeur d’ID 30 dans *source\$1table*, les deux lignes dupliquées avec des valeurs d’ID 30 restent dans *target\$1table*. ## Consultez aussi [INSERT](r_INSERT_30.md), [UPDATE](r_UPDATE.md), [DELETE](r_DELETE.md)