Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # 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](https://docs.aws.amazon.com/redshift/latest/dg/r_UPDATE.html), [DELETE](https://docs.aws.amazon.com/redshift/latest/dg/r_DELETE.html) e [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html). ## 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 ] ``` ## Parameters *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ò essere anche 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 Inserimenti nelle righe *target\_table* di *source\_table* che non corrispondono ad alcuna 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, tipi di colonna compatibili e lo stesso ordine di colonne. + 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](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html). + 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 un’origine dati di alcuna sottoquery della stessa istruzione MERGE. Ad esempio, il seguente comando SQL restituisce un errore come ERROR: L'istruzione Source view/subquery in Merge non può fare riferimento alla tabella di destinazione. perché la subquery fa riferimento `target` invece a. `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, che rimuove le righe duplicate da *target\_table* se ci sono 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](r_INSERT_30.md), [UPDATE](r_UPDATE.md), [DELETE](r_DELETE.md)