Sintassi Parametri Note per l'utilizzo Esempi Consulta anche

MERGE

Unisce in modo condizionale le righe da una tabella di origine a una tabella di destinazione. In genere, ciò può essere ottenuto solo utilizzando separatamente più istruzioni di inserimento, aggiornamento o eliminazione. Per ulteriori informazioni sulle operazioni che MERGE consente di combinare, consulta UPDATE, DELETE e INSERT.

Sintassi


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 ]

Parametri

target_table

La tabella temporanea o permanente in cui si include l'istruzione MERGE.

source_table

La tabella temporanea o permanente che fornisce le righe da unire in target_table. source_table può anche essere una tabella Spectrum.

alias

Nome alternativo temporaneo per source_table.

Questo parametro è facoltativo. Anche il precedente alias con AS è facoltativo.

match_condition

Specifica predicati uguali tra la colonna della tabella di origine e la colonna della tabella di destinazione che vengono utilizzati per determinare se le righe in source_table possono essere abbinate alle righe in target_table. Se la condizione è soddisfatta, MERGE esegue matched_clause per quella riga. In caso contrario, MERGE esegue not_matched_clause per quella riga.

WHEN MATCHED

Specifica l'operazione da eseguire quando la condizione di corrispondenza tra una riga di origine e una riga di destinazione risulta True. È possibile specificare un'azione UPDATE o un'azione DELETE.

UPDATE

Aggiorna la riga corrispondente in target_table. Vengono aggiornati solo i valori nel col_name specificato.

DELETE

Elimina la riga corrispondente in target_table.

WHEN NOT MATCHED

Specifica l'operazione da eseguire quando la condizione di corrispondenza risulta False o Unknown. È possibile specificare solo l'azione di inserimento INSERT per questa clausola.

INSERT

Inserisce in target_table righe da source_table che non corrispondono a nessuna riga in target_table, secondo match_condition. Il col_name di destinazione può essere elencato in qualsiasi ordine. Se non viene fornito alcun valore col_name, per impostazione predefinita l'ordine è quello di tutte le colonne della tabella nel loro ordine dichiarato.

nome_col

Una o più nomi di colonne da modificare. Non includere il nome della tabella quando specifichi la colonna di destinazione.

expr

L'espressione che definisce il nuovo valore per col_name.

REMOVE DUPLICATES

Specifica che il comando MERGE viene eseguito in modalità semplificata. La modalità semplificata presenta i seguenti requisiti:

target_table e source_table devono avere lo stesso numero di colonne e tipi di colonna compatibili.
Ometti la clausola WHEN e le clausole UPDATE e INSERT dal comando MERGE.
Usa la clausola REMOVE DUPLICATES nel comando MERGE.

In modalità semplificata, MERGE esegue le seguenti operazioni:

Le righe in target_table che hanno una corrispondenza in source_table vengono aggiornate in modo che corrispondano ai valori in source_table.
Le righe in source_table che non hanno una corrispondenza in target_table vengono inserite in target_table.
Quando più righe in target_table corrispondono alla stessa riga in source_table, le righe duplicate vengono rimosse. Amazon Redshift mantiene una riga e la aggiorna. Le righe duplicate che non corrispondono a una riga in source_table restano invariate.

L'utilizzo di REMOVE DUPLICATES offre prestazioni migliori rispetto all'utilizzo di WHEN MATCHED e WHEN NOT MATCHED. Consigliamo di utilizzare REMOVE DUPLICATES se target_table e source_table sono compatibili e non è necessario conservare le righe duplicate in target_table.

Note per l'utilizzo

Per eseguire le istruzioni MERGE, devi essere il proprietario sia di source_table che di target_table o disporre dell'autorizzazione SELECT per tali tabelle. Inoltre, devi disporre delle autorizzazioni UPDATE, DELETE e INSERT per target_table, a seconda delle operazioni incluse nell'istruzione MERGE.
target_table non può essere una tabella di sistema, una tabella di catalogo o una tabella esterna.
source_table e target_table non possono essere la stessa tabella.
Non è possibile utilizzare la clausola WITH in un'istruzione MERGE.

Le righe in target_table non possono corrispondere a più righe in source_table.

Considera il seguente esempio:


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.

In entrambe le istruzioni MERGE, l'operazione non riesce perché nella tabella source sono presenti più righe con un valore ID di 1.

match_condition ed expr non possono fare riferimento parzialmente a colonne di tipo SUPER. Ad esempio, se l'oggetto di tipo SUPER è un array o una struttura, non puoi usare singoli elementi di quella colonna per match_condition o expr, ma puoi utilizzare l'intera colonna.

Considera il seguente esempio:


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.

Per ulteriori informazioni sul tipo SUPER, consulta Tipo SUPER.

Se source_table è di grandi dimensioni, la definizione delle colonne di join sia da target_table che da source_table come chiavi di distribuzione può migliorare le prestazioni.
Per utilizzare la clausola REMOVE DUPLICATES, sono necessarie le autorizzazioni SELECT, INSERT e DELETE per target_table.

source_table può essere una vista o una sottoquery. Di seguito è riportato un esempio di istruzione MERGE in cui source_table è una sottoquery che rimuove le righe duplicate.


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 destinazione non può essere una fonte di dati di alcuna sottoquery della stessa istruzione MERGE. Ad esempio, il seguente comando SQL restituisce un errore del tipo ERROR: L'istruzione Source view/subquery in Merge non può fare riferimento alla tabella di destinazione. perché la sottoquery fa riferimento invece a. target 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);
```

Esempi

L'esempio seguente crea due tabelle, quindi esegue un'operazione MERGE su di esse, aggiornando le righe corrispondenti nella tabella di destinazione e inserendo righe che prive di corrispondenze. Quindi inserisce un altro valore nella tabella di origine ed esegue un'altra operazione MERGE, questa volta eliminando le righe corrispondenti e inserendo la nuova riga dalla tabella di origine.

Per prima cosa crea e compila le tabelle di origine e destinazione.


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)

Quindi, unisci la tabella di origine con la tabella di destinazione, aggiornando la tabella di destinazione con le righe corrispondenti e inserisci le righe della tabella di origine che non hanno alcuna corrispondenza.


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)

Tieni presente che le righe con valori ID di 102 e 103 vengono aggiornate in modo che corrispondano ai valori dei nomi della tabella di destinazione. Inoltre, nella tabella di destinazione viene inserita una nuova riga con un valore ID di 104 e il valore del nome Bill.

Quindi, inserisci una nuova riga nella tabella di origine.


INSERT INTO source VALUES (105, 'David');

SELECT * FROM source;
 id  |    name
-----+------------
 102 | Tony
 103 | Alice
 104 | Bill
 105 | David
(4 rows)

Infine, esegui un'operazione di unione eliminando le righe corrispondenti nella tabella di destinazione e inserendo le righe prive di corrispondenze.


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)

Le righe con valori ID di 102, 103 e 104 vengono eliminate dalla tabella di destinazione e una nuova riga con un valore ID di 105 e il valore del nome David viene inserita nella tabella di destinazione.

L'esempio seguente mostra la sintassi semplificata di un comando MERGE che utilizza la clausola 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'esempio seguente mostra la sintassi semplificata di un comando MERGE che utilizza la clausola REMOVE DUPLICATES, rimuovendo le righe duplicate da target_table se hanno righe corrispondenti in source_table.


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)

Dopo l'esecuzione di MERGE, c'è solo una riga con un valore ID di 23 in target_table. Poiché non c'era alcuna riga in source_table con il valore ID 30, le due righe duplicate con valori ID 30 rimangono in target_table.

consultare anche

INSERT, UPDATE, DELETE

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

LOCK

PREPARE