Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # MERGE Führt Zeilen aus einer Quelltabelle bedingt in einer Zieltabelle zusammen. Herkömmlicherweise ist dies nur durch separate Verwendung mehrerer Insert-, Update- oder Delete-Anweisungen möglich. Weitere Informationen zu den Operationen, die Sie mithilfe von MERGE kombinieren können, finden Sie unter [UPDATE](https://docs.aws.amazon.com/redshift/latest/dg/r_UPDATE.html), [DELETE](https://docs.aws.amazon.com/redshift/latest/dg/r_DELETE.html) und [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html). ## Syntax ``` 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\_table* Die temporäre oder permanente Tabelle, in die die MERGE-Anweisung zusammengeführt wird. *source\_table* Die temporäre oder permanente Tabelle, die die Zeilen bereitstellt, die in *target\_table* zusammengeführt werden sollen. *source\_table* kann auch eine Spectrum-Tabelle sein. *alias* Der temporäre alternative Name für *source\_table*. Dieser Parameter ist optional. Optional kann dem *Alias* auch AS vorangestellt sein. *match\_condition* Gibt übereinstimmende Prädikate zwischen der Quelltabellenspalte und der Zieltabellenspalte an, anhand derer bestimmt wird, ob die Zeilen in *source\_table* mit Zeilen in *target\_table* abgeglichen werden können. Wenn die Bedingung erfüllt ist, führt MERGE *matched\_clause* für diese Zeile aus. Andernfalls führt MERGE *not\_matched\_clause* für diese Zeile aus. WHEN MATCHED Gibt die Aktion an, die ausgeführt werden soll, wenn die Übereinstimmungsbedingung zwischen einer Quell- und einer Zielzeile „True“ (Wahr) ergibt. Sie können entweder eine UPDATE-Aktion oder eine DELETE-Aktion angeben. UPDATE Aktualisiert die übereinstimmende Zeile in *target\_table*. Nur Werte in dem von Ihnen angegebenen *col\_name* werden aktualisiert. DELETE Löscht die übereinstimmende Zeile in *target\_table*. WHEN NOT MATCHED Gibt die Aktion an, die ausgeführt werden soll, wenn die Übereinstimmungsbedingung „False“ (Falsch) oder „Unknown“ (Unbekannt) ergibt. Sie können nur die INSERT-Einfügeaktion für diese Klausel angeben. INSERT Fügt in *target\_table* Zeilen aus *source\_table* ein, die mit keiner Zeile in *target\_table* übereinstimmen, abhängig von *match\_condition*. Der Ziel-*col\_name* kann in beliebiger Reihenfolge aufgelistet werden. Wenn Sie keine *col\_name*-Werte angeben, werden standardmäßig alle Spalten der Tabelle in ihrer deklarierten Reihenfolge angeordnet. *col\_name* Ein oder mehrere Spaltennamen, die Sie ändern möchten. Beziehen Sie den Tabellennamen bei der Angabe der Zielspalte nicht ein. *expr* Der Ausdruck, der den neuen Wert für *col\_name* definiert. REMOVE DUPLICATES Gibt an, dass der MERGE-Befehl im vereinfachten Modus ausgeführt wird. Für den vereinfachten Modus gelten folgende Anforderungen: + *target\_table* und *source\_table* müssen über dieselbe Anzahl von Spalten, kompatible Spaltentypen und dieselbe Spaltenreihenfolge verfügen. + Lassen Sie die WHEN-Klausel und die UPDATE- und INSERT-Klauseln in Ihrem MERGE-Befehl weg. + Verwenden Sie die REMOVE DUPLICATES-Klausel in Ihrem MERGE-Befehl. Im vereinfachten Modus bewirkt MERGE Folgendes: + Zeilen in *target\_table*, die eine Übereinstimmung in *source\_table* haben, werden aktualisiert, so dass sie den Werten in *source\_table* entsprechen. + Zeilen in *source\_table*, die keine Übereinstimmung in *target\_table* haben, werden in *target\_table* eingefügt. + Wenn mehrere Zeilen in *target\_table* mit derselben Zeile in *source\_table* übereinstimmen, werden die doppelten Zeilen entfernt. Amazon Redshift behält eine Zeile bei und aktualisiert sie. Doppelte Zeilen, die keiner Zeile in *source\_table* entsprechen, bleiben unverändert. Die Verwendung von REMOVE DUPLICATES bietet eine bessere Leistung als die Verwendung von WHEN MATCHED und WHEN NOT MATCHED. Wir empfehlen die Verwendung von REMOVE DUPLICATES, wenn *target\_table* und *source\_table* kompatibel sind und Sie keine doppelten Zeilen in *target\_table* beibehalten müssen. ## Nutzungshinweise + Um MERGE-Anweisungen ausführen zu können, müssen Sie sowohl Besitzer von *source\_table* als auch von *target\_table* sein oder über die SELECT-Berechtigung für diese Tabellen verfügen. Darüber hinaus benötigen Sie UPDATE-, DELETE- und INSERT-Berechtigungen für *target\_table*, je nachdem, welche Operationen in Ihrer MERGE-Anweisung enthalten sind. + *target\_table* kann keine Systemtabelle, Katalogtabelle oder externe Tabelle sein. + *source\_table* und *target\_table* können nicht dieselbe Tabelle sein. + Sie können die WITH-Klausel nicht in einer MERGE-Anweisung verwenden. + Zeilen in *target\_table* können nicht mit mehreren Zeilen in *source\_table* übereinstimmen. Betrachten Sie das folgende Beispiel: ``` 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. ``` Bei beiden MERGE-Anweisungen schlägt der Vorgang fehl, da es mehrere Zeilen in der `source`-Tabelle mit einem ID-Wert von `1` gibt. + *match\_condition* und *expr* können nicht teilweise auf Spalten vom Typ SUPER verweisen. Wenn Ihr Objekt vom Typ SUPER beispielsweise ein Array oder eine Struktur ist, können Sie nicht einzelne Elemente dieser Spalte für *match\_condition* oder *expr* verwenden, die gesamte Spalte dagegen schon. Betrachten Sie das folgende Beispiel: ``` 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. ``` Weitere Informationen zum Typ SUPER finden Sie unter [Typ SUPER](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html). + Bei einer großen *source\_table* kann die Leistung verbessert werden, indem die Join-Spalten von *target\_table* und *source\_table* als Verteilungsschlüssel definiert werden. + Um die REMOVE DUPLICATES-Klausel benutzen zu können, benötigen Sie die SELECT-, INSERT- und DELETE-Berechtigungen für *target\_table*. + *source\_table* kann eine Ansicht oder Unterabfrage sein. Im Folgenden finden Sie ein Beispiel für eine MERGE-Anweisung, bei der *source\_table* eine Unterabfrage ist, die duplizierte Zeilen entfernt. ``` 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); ``` + Das Ziel darf keine Datenquelle einer Unterabfrage derselben MERGE-Anweisung sein. Der folgende SQL-Befehl gibt beispielsweise einen Fehler wie ERROR zurück: Die Anweisung Source view/subquery in Merge kann nicht auf die Zieltabelle verweisen. weil die Unterabfrage `target` statt auf verweist. `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); ``` ## Beispiele Im folgenden Beispiel werden zwei Tabellen erstellt und anschließend wird eine MERGE-Operation für sie ausgeführt. Dabei werden übereinstimmende Zeilen in der Zieltabelle aktualisiert und nicht übereinstimmende Zeilen eingefügt. Daraufhin wird ein weiterer Wert in die Quelltabelle eingefügt und eine weitere MERGE-Operation ausgeführt. Dieses Mal werden dabei übereinstimmende Zeilen gelöscht und die neue Zeile aus der Quelltabelle wird eingefügt. Erstellen Sie zunächst die Quell- und Zieltabellen und füllen Sie sie aus. ``` 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) ``` Führen Sie anschließend die Quelltabelle mit der Zieltabelle zusammen. Aktualisieren Sie dabei die Zieltabelle mit übereinstimmenden Zeilen und fügen Sie Zeilen aus der Quelltabelle ein, zu denen es keine Übereinstimmung gibt. ``` 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) ``` Beachten Sie, dass die Zeilen mit den ID-Werten 102 und 103 aktualisiert werden, sodass sie den Namenswerten aus der Zieltabelle entsprechen. Außerdem wird eine neue Zeile mit dem ID-Wert 104 und dem Namenswert „Bill“ in die Zieltabelle eingefügt. Fügen Sie als Nächstes eine neue Zeile in die Quelltabelle ein. ``` INSERT INTO source VALUES (105, 'David'); SELECT * FROM source; id | name -----+------------ 102 | Tony 103 | Alice 104 | Bill 105 | David (4 rows) ``` Führen Sie abschließend eine Merge-Operation aus. Löschen Sie dabei übereinstimmende Zeilen in der Zieltabelle und fügen Sie nicht übereinstimmende Zeilen ein. ``` 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) ``` Die Zeilen mit den ID-Werten 102, 103 und 104 werden aus der Zieltabelle gelöscht, und eine neue Zeile mit dem ID-Wert 105 und dem Namenswert „David“ wird in die Zieltabelle eingefügt. Das folgende Beispiel zeigt die vereinfachte Syntax eines MERGE-Befehls unter Verwendung der Klausel 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) ``` Das folgende Beispiel zeigt die vereinfachte Syntax eines MERGE-Befehls, der die Klausel REMOVE DUPLICATES verwendet und duplizierte Zeilen aus *target\_table* entfernt, wenn es für sie übereinstimmende Zeilen in *source\_table* gibt. ``` 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) ``` Nach der Ausführung von MERGE gibt es in *target\_table* nur eine Zeile mit dem ID-Wert 23. Da es in *source\_table* keine Zeile mit dem ID-Wert 30 gab, verbleiben die beiden doppelten Zeilen mit den ID-Werten 30 in *target\_table*. ## Weitere Informationen finden Sie auch unter [INSERT](r_INSERT_30.md), [UPDATE](r_UPDATE.md), [DELETE](r_DELETE.md)