O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). # MERGE Mescla condicionalmente as linhas de uma tabela de origem em uma tabela de destino. Tradicionalmente, isso só pode ser feito usando várias instruções insert, update ou delete separadamente. Para obter mais informações sobre as operações que MERGE permite combinar, consulte [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). ## Sintaxe ``` 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 ] ``` ## Parâmetros *target\$1table* A tabela temporária ou permanente de destino da instrução MERGE. *source\$1table* A tabela temporária ou permanente que fornece as linhas a serem mescladas em *target\$1table*. *source\$1table* também pode ser uma tabela do Spectrum. *alias* O nome alternativo temporário para *source\$1table*. Esse parâmetro é opcional. O *alias* precedente com AS também é opcional. *match\$1condition* Especifica predicados iguais entre a coluna da tabela de origem e a coluna da tabela de destino que são usados para determinar se as linhas em *source\$1table* podem ser combinadas com as linhas em *target\$1table*. Se a condição for atendida, MERGE executará *matched\$1clause* para essa linha. Caso contrário, MERGE executará *not\$1matched\$1clause* para essa linha. WHEN MATCHED Especifica a ação a ser executada quando a condição de correspondência entre uma linha de origem e uma linha de destino é avaliada como True. Você pode especificar uma ação UPDATE ou uma ação DELETE. UPDATE Atualiza a linha correspondente em *target\$1table*. Somente os valores no *col\$1name* que você especificar serão atualizados. DELETE Exclui a linha correspondente em *target\$1table*. WHEN NOT MATCHED Especifica a ação a ser executada quando a condição de correspondência é avaliada como False ou Unknown. Você só pode especificar a ação de inserção INSERT para essa cláusula. INSERT Insere linhas de *source\$1table* em *target\$1table* que não correspondem a nenhuma linha em *target\$1table*, de acordo com *match\$1condition*. O *col\$1name* de destino pode ser listado em qualquer ordem. Se você não fornecer nenhum valor de *col\$1name*, a ordem padrão será todas as colunas da tabela na ordem declarada. *col\$1name* Um ou mais nomes de coluna que você deseja modificar. Não inclui o nome da tabela ao especificar a coluna de destino. *expr* A expressão que define o novo valor para *col\$1name*. REMOVE DUPLICATES Especifica que o comando MERGE é executado no modo simplificado. O modo simplificado tem os seguintes requisitos: + *target\$1table* e *source\$1table* devem ter o mesmo número de colunas, tipos de coluna compatíveis e a mesma ordem de coluna. + A cláusula WHEN e as cláusulas UPDATE e INSERT devem ser omitidas do comando MERGE. + A cláusula REMOVE DUPLICATES deve ser usada no comando MERGE. No modo simplificado, o MERGE faz o seguinte: + As linhas em *target\$1table* que têm uma correspondência em *source\$1table* são atualizadas para corresponder aos valores em *source\$1table*. + As linhas em *source\$1table* que não têm uma correspondência em *target\$1table* são inseridas em *target\$1table*. + Quando várias linhas em *target\$1table* correspondem à mesma linha em *source\$1table*, as linhas duplicadas são removidas. O Amazon Redshift mantém uma única linha e a atualiza. As linhas duplicadas que não correspondem a uma linha em *source\$1table* permanecem inalteradas. REMOVE DUPLICATES oferece melhor performance do que WHEN MATCHED e WHEN NOT MATCHED. Recomendamos usar REMOVE DUPLICATES se *target\$1table* e *source\$1table* forem compatíveis e você não precisar preservar linhas duplicadas em *target\$1table*. ## Observações de uso + Para executar instruções MERGE, você deve ser o proprietário das tabelas *source\$1table* e *target\$1table* ou ter a permissão SELECT para essas tabelas. Além disso, você deve ter as permissões UPDATE, DELETE e INSERT para *target\$1table*, dependendo das operações incluídas em sua instrução MERGE. + *target\$1table* não pode ser uma tabela do sistema, tabela de catálogo ou tabela externa. + *source\$1table* e *target\$1table* não podem ser a mesma tabela. + Não é possível usar a cláusula WITH em uma instrução MERGE. + As linhas em *target\$1table* não podem estabelecer correspondência com várias linhas em *source\$1table*. Considere o seguinte exemplo: ``` 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. ``` Nas duas instruções MERGE, a operação falha porque há várias linhas na tabela `source` com um valor de ID de `1`. + *match\$1condition* e *expr* não podem fazer referência parcial a colunas do tipo SUPER. Por exemplo, se seu objeto do tipo SUPER for uma matriz ou uma estrutura, você não poderá usar elementos individuais dessa coluna para *match\$1condition* ou *expr*, mas poderá usar a coluna inteira. Considere o seguinte exemplo: ``` 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. ``` Para obter mais informações sobre o tipo SUPER, consulte [Tipo SUPER](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html). + Se *source\$1table* for grande, definir as colunas de junção de *target\$1table* e *source\$1table* como chaves de distribuição poderá melhorar a performance. + Para usar a cláusula REMOVE DUPLICATES, você precisa das permissões SELECT, INSERT e DELETE para *target\$1table*. + *source\$1table* pode ser uma visualização ou subconsulta. Veja a seguir um exemplo de uma instrução MERGE em que *source\$1table* é uma subconsulta que remove linhas duplicadas. ``` 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); ``` + O destino não pode ser uma fonte de dados de nenhuma subconsulta da mesma instrução MERGE. Por exemplo, o comando SQL a seguir retorna um erro como ERRO: a visualização/subconsulta de origem na instrução MERGE não pode fazer referência à tabela de destino. porque a subconsulta faz referência a `target` em vez 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); ``` ## Exemplos O exemplo a seguir cria duas tabelas e executa uma operação MERGE nelas, atualizando as linhas correspondentes na tabela de destino e inserindo linhas que não correspondem. Depois, ele insere outro valor na tabela de origem e executa outra operação MERGE, desta vez excluindo as linhas correspondentes e inserindo a nova linha da tabela de origem. Primeiro, crie e preencha as tabelas de origem e de destino. ``` 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) ``` Depois, mescle a tabela de origem com a tabela de destino, atualizando a tabela de destino com linhas correspondentes e insira linhas da tabela de origem que não tenham correspondência. ``` 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) ``` Observe que as linhas com valores de id 102 e 103 são atualizadas para corresponder aos valores dos nomes da tabela de destino. Além disso, uma nova linha com um valor de id 104 e o valor de nome Bill é inserida na tabela de destino. Depois, insira uma nova linha na tabela de origem. ``` INSERT INTO source VALUES (105, 'David'); SELECT * FROM source; id | name -----+------------ 102 | Tony 103 | Alice 104 | Bill 105 | David (4 rows) ``` Por fim, execute uma operação de mesclagem excluindo linhas correspondentes na tabela de destino e inserindo linhas que não correspondem. ``` 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) ``` As linhas com valores de id 102, 103 e 104 são excluídas da tabela de destino, e uma nova linha com um valor de id 105 e valor de nome David é inserida na tabela de destino. O exemplo a seguir mostra a sintaxe simplificada de um comando MERGE que usa a cláusula 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) ``` O exemplo a seguir mostra a sintaxe simplificada de um comando MERGE que usa a cláusula REMOVE DUPLICATES, que remove linhas duplicadas de *target\$1table* quando elas têm linhas correspondentes em *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) ``` Depois que MERGE é executado, há apenas uma linha com um valor de ID de 23 em *target\$1table*. Como não havia nenhuma linha em *source\$1table* com o valor de ID 30, as duas linhas duplicadas com valores de ID de 30 permanecem em *target\$1table*. ## Consulte também [INSERT](r_INSERT_30.md), [UPDATE](r_UPDATE.md), [DELETE](r_DELETE.md)