Como deduplicar dados no BigQuery: MERGE, QUALIFY e ROW_NUMBER

Encontre e remova linhas duplicadas no BigQuery com DISTINCT, ROW_NUMBER com QUALIFY e MERGE, e veja quanto custa cada método.

Como deduplicar dados no BigQuery

O seu dashboard de receita mostra mais dinheiro do que o time de finanças contabilizou. Quando você confere a tabela de pedidos no BigQuery, vê o pedido 1002 duas vezes, uma com status "pending" e outra como "paid". Também vê o pedido 1001 duas vezes, com os mesmos valores em todas as colunas, exceto o horário em que o registro foi carregado. Qualquer soma, contagem ou join com essa tabela vai sair errado.

Como as duplicatas surgiram durante a carga, e não no sistema de origem, você vai precisar limpar os dados no warehouse usando SQL e também mudar o processo de carga para evitar que as mesmas linhas sejam carregadas duas vezes. Nas queries a seguir, vou usar uma pequena tabela de pedidos para mostrar o que cada método mantém e o que descarta.

Por que aparecem duplicatas no BigQuery

Estes são alguns padrões de carga que geram duplicatas:

  1. Uma carga falha e é refeita. Se uma carga falha no meio, ou demora demais e dá timeout, o pipeline pode tentar carregar os dados de novo. Se parte da primeira carga já tinha sido gravada, o retry faz os mesmos dados serem carregados duas vezes. Em streaming inserts, não dá para saber se o insert deu certo quando há um erro de rede, então um retry pode criar duplicatas.
  2. Os registros mudam e são carregados com append. Digamos que estamos carregando pedidos. Cada vez que o status de um pedido muda, adicionamos uma nova linha à tabela. A linha original continua lá, e agora existem várias linhas para o mesmo pedido.
  3. Uma carga incremental com janelas sobrepostas. Uma carga incremental pode selecionar registros que mudaram desde a carga anterior. Se ela usa um filtro do tipo "maior ou igual" ao último valor, ou se recarrega os últimos dias por precaução, alguns registros na borda vão acabar sendo carregados mais de uma vez.
  4. Uma carga de full refresh feita com append em vez de substituição. Se um job carrega a tabela inteira a cada execução, ele deveria sobrescrever a tabela de destino. Se ele faz append, cada execução cria mais uma cópia da tabela inteira.
  5. Ausência de chave primária nos dados de origem. Alguns endpoints de API e tabelas de log não têm uma coluna que identifique um registro de forma única. Nesses casos, não há como distinguir uma duplicata de uma linha legítima, e elas se acumulam sem ninguém perceber.

O BigQuery não impede nenhum desses casos. Mesmo que você declare uma chave primária em uma tabela, o BigQuery só suporta constraints que não são aplicadas. Ele aceita sem problema outro registro com a mesma chave primária.

Veja um exemplo de como a primeira e a terceira causas podem fazer linhas duplicadas do mesmo pedido serem carregadas:

Como encontrar linhas duplicadas no BigQuery?

Podemos usar HAVING COUNT(*) > 1 na chave de negócio da tabela para encontrar linhas duplicadas. As chaves de negócio que aparecem aqui têm mais de uma linha associada. A chave de negócio é a coluna que deveria ser única para cada registro, como o ID do pedido.

Os exemplos deste guia usam uma tabela chamada shop.raw_orders com 5 linhas. O pedido 1001 foi carregado duas vezes por um retry. O pedido 1002 foi carregado uma vez como pending e outra como paid. O pedido 1003 aparece só uma vez.

SELECT order_id, COUNT(*) AS copies
FROM `shop.raw_orders`
GROUP BY order_id
HAVING COUNT(*) > 1
ORDER BY copies DESC;

order_id | copies
---------+-------
1001 | 2
1002 | 2

Os dois pedidos parecem iguais nesse resultado, mas precisam de correções diferentes. Para diferenciá-los, conte quantos valores diferentes de updated_at cada chave tem:

SELECT
order_id,
COUNT(*) AS copies,
COUNT(DISTINCT updated_at) AS versions
FROM `shop.raw_orders`
GROUP BY order_id
HAVING COUNT(*) > 1
ORDER BY order_id;

order_id | copies | versions
---------+--------+---------
1001 | 2 | 1
1002 | 2 | 2

Quando copies é maior que versions, algumas linhas são cópias exatas do mesmo registro, como o pedido 1001. Quando versions é maior que um, algum registro mudou e cada mudança virou uma linha, como o pedido 1002. A maioria das tabelas tem os dois tipos, e só os dois próximos métodos resolvem o segundo.

Método 1: SELECT DISTINCT

O SELECT DISTINCT retorna exatamente uma linha para cada conjunto de linhas duplicadas (sendo duplicadas as linhas com o mesmo valor em todas as colunas da lista do SELECT). Por isso, ele só serve para duplicatas exatas.

Na tabela de exemplo, SELECT DISTINCT * retorna as cinco linhas. As duas cópias do pedido 1001 diferem em _loaded_at, a coluna que o loader preenche com o horário da carga, então o DISTINCT as trata como linhas diferentes. Deixar essa coluna de fora resolve a cópia exata:

SELECT DISTINCT * EXCEPT (_loaded_at)
FROM `shop.raw_orders`;

order_id | customer_id | status | amount | updated_at
---------+-------------+---------+--------+------------------------
1001 | 101 | paid | 120.00 | 2026-10-19 18:00:00 UTC
1002 | 102 | paid | 80.00 | 2026-10-20 09:00:00 UTC
1002 | 102 | pending | 80.00 | 2026-10-19 10:00:00 UTC
1003 | 103 | shipped | 45.50 | 2026-10-18 08:00:00 UTC

O pedido 1001 ficou com uma linha só, mas o 1002 continuou com duas, porque as linhas têm valores diferentes em status e updated_at. O DISTINCT não sabe qual versão é a mais recente. Por isso, tabelas que recebem atualizações precisam de algum método que escolha explicitamente uma linha por chave.

Método 2: ROW_NUMBER() com QUALIFY

Esta é a query para usar quando uma tabela tem várias versões do mesmo registro e você quer a mais recente:

SELECT *
FROM `shop.raw_orders`
QUALIFY ROW_NUMBER() OVER (
PARTITION BY order_id
ORDER BY updated_at DESC, _loaded_at DESC
) = 1;

order_id | customer_id | status | amount | updated_at | _loaded_at
---------+-------------+---------+--------+-------------------------+------------------------
1001 | 101 | paid | 120.00 | 2026-10-19 18:00:00 UTC | 2026-10-20 03:05:00 UTC
1002 | 102 | paid | 80.00 | 2026-10-20 09:00:00 UTC | 2026-10-20 12:00:00 UTC
1003 | 103 | shipped | 45.50 | 2026-10-18 08:00:00 UTC | 2026-10-18 12:00:00 UTC

Nesse resultado, vemos 3 pedidos, com 1 linha por pedido. O pedido 1002 aparece como "paid". Veja o que está acontecendo:

  • ROW_NUMBER() numera as linhas a partir de 1. É uma window function, ou seja, opera sobre um conjunto de linhas e não sobre uma única linha.
  • PARTITION BY order_id reinicia a numeração para cada pedido.
  • ORDER BY updated_at DESC ordena as versões de cada pedido para que a mais recente venha primeiro.
  • QUALIFY … = 1 filtra só a versão mais recente de cada pedido. O QUALIFY filtra com base em window functions do mesmo jeito que o WHERE filtra com base em colunas comuns.

Se você não tiver o QUALIFY, pode calcular o número da linha como uma coluna em uma subquery e depois filtrar WHERE row_num = 1 na query externa. O resultado é o mesmo do exemplo acima, com uma camada a mais de aninhamento.

A segunda coluna do ORDER BY desempata. Como as duas cópias do pedido 1001 têm o mesmo updated_at, o desempate é necessário para que o ORDER BY seja único por linha. Se as linhas forem idênticas em todas as colunas do ORDER BY, o BigQuery pode retorná-las em qualquer ordem e escolher uma linha diferente na próxima execução. Para cópias exatas, isso não é problema. Mas, se duas versões diferentes do mesmo pedido tivessem o mesmo updated_at, a linha "mais recente" poderia mudar de uma execução para outra. Adicionar o horário da carga (ou qualquer outra coluna única por linha) resolve isso.

Uma limitação da chave é que tipos de ponto flutuante não podem ser usados na expressão do PARTITION BY. Se a sua chave está armazenada como FLOAT64, converta-a para string ou inteiro antes.

Método 3: MERGE

As duas primeiras abordagens, DISTINCT e QUALIFY, limpam os dados na leitura. O MERGE serve para manter uma tabela limpa atualizada conforme chegam novos lotes, sem nunca ter duplicatas na tabela. O pipeline carrega cada novo lote em uma tabela de staging e depois roda um MERGE para atualizar os pedidos existentes e inserir os novos. Isso costuma ser chamado de upsert (update ou insert).

O pipeline abaixo mostra como cada lote de dados é processado.

No exemplo, a tabela limpa shop.orders tem três pedidos, com o 1002 ainda como "pending". Um novo lote chega em shop.orders_batch. Ele contém o pedido 1002 como "paid" duas vezes, porque um retry o carregou duas vezes. Ele também tem um pedido novo, o 1004, e o pedido 1003 sem mudanças:

MERGE `shop.orders` AS t
USING (
SELECT *
FROM `shop.orders_batch`
QUALIFY ROW_NUMBER() OVER (
PARTITION BY order_id
ORDER BY updated_at DESC, _loaded_at DESC
) = 1
) AS s
ON t.order_id = s.order_id
WHEN MATCHED AND s.updated_at > t.updated_at THEN
UPDATE SET
status = s.status,
amount = s.amount,
updated_at = s.updated_at,
_loaded_at = s._loaded_at
WHEN NOT MATCHED THEN INSERT ROW;

Depois do MERGE, a tabela limpa tem uma linha por pedido:

order_id | customer_id | status | amount | updated_at | _loaded_at
---------+-------------+---------+--------+-------------------------+------------------------
1001 | 101 | paid | 120.00 | 2026-10-19 18:00:00 UTC | 2026-10-20 03:05:00 UTC
1002 | 102 | paid | 80.00 | 2026-10-20 09:00:00 UTC | 2026-10-20 12:05:00 UTC
1003 | 103 | shipped | 45.50 | 2026-10-18 08:00:00 UTC | 2026-10-18 12:00:00 UTC
1004 | 104 | pending | 60.00 | 2026-10-21 07:00:00 UTC | 2026-10-21 08:00:00 UTC

Cada cláusula tem uma função específica:

  • ON t.order_id = s.order_id: para cada linha do lote, faz o join com a linha da tabela limpa que tem a mesma chave.
  • WHEN MATCHED AND s.updated_at > t.updated_at: só atualiza a linha se recebemos uma versão mais nova do pedido no lote. O pedido 1003 já está na tabela limpa e não mudou no lote, então o MERGE não mexe nele.
  • WHEN NOT MATCHED THEN INSERT ROW: insere os pedidos que nunca vimos antes (o pedido 1004).

O QUALIFY dentro da cláusula USING é fundamental. Comandos MERGE com uma cláusula UPDATE não podem ter duas linhas da origem correspondendo à mesma linha do destino; se isso acontecer, o BigQuery retorna o erro UPDATE/MERGE must match at most one source row for each target row. As linhas duplicadas do 1002 no lote causariam esse erro, então primeiro deduplicamos o lote.

Um caso traiçoeiro são as chaves NULL. Como NULL = NULL não é verdadeiro em SQL, uma linha da origem com chave NULL nunca vai encontrar correspondência no destino e vai ser inserida de novo a cada execução. Se a sua chave pode ser NULL, faça a correspondência com t.key = s.key OR (t.key IS NULL AND s.key IS NULL) ou filtre essas linhas do lote.

Quanto custa cada método no preço on-demand

O modelo de preço on-demand cobra por byte lido pela query (não por linha retornada). No momento em que escrevo, o BigQuery cobra US$ 6,25 por TiB processado, depois do primeiro TiB gratuito de cada mês. Ele só conta as colunas lidas, e um LIMIT não dá desconto. Há um mínimo de 10 MB por tabela em cada query.

Isso significa que as abordagens com DISTINCT e com QUALIFY vão ser cobradas pela mesma quantidade de bytes para as mesmas colunas lidas da mesma tabela, porque, mesmo que a window function dê mais trabalho, ela não exige ler mais bytes.

Já o MERGE é cobrado pelos bytes lidos mais o tamanho da tabela de destino se tiver uma cláusula UPDATE ou DELETE (se tiver só cláusulas INSERT, é cobrado apenas pelos bytes lidos).

Vamos calcular o custo de um cenário de exemplo. Digamos que temos uma tabela bruta de 500 GiB e uma tabela limpa de 200 GiB. Cada lote diário tem 2 GiB, e as colunas de chave e updated_at da tabela limpa somam 8 GiB. Lembre-se de que 1 TiB = 1.024 GiB.

Rebuild the clean table from raw every day (DISTINCT or QUALIFY)
500 GiB / 1,024 = 0.488 TiB x $6.25 = $3.05 per run
30 runs = $91.55 per month

MERGE each daily batch (UPDATE + INSERT)
read: 2 GiB batch + 8 GiB target columns = 10 GiB
target: 200 GiB
210 GiB / 1,024 = 0.205 TiB x $6.25 = $1.28 per run
30 runs = $38.45 per month

MERGE each daily batch (INSERT only)
10 GiB / 1,024 = 0.0098 TiB x $6.25 = $0.06 per run

A reconstrução paga o custo de processar a tabela bruta inteira toda vez, e a tabela bruta continua crescendo com o tempo, enquanto o MERGE processa a tabela limpa, que só cresce com registros novos. Se os dados não mudam depois de gravados (por exemplo, eventos e logs), um MERGE só com INSERT é a forma mais barata de atualizá-los.

Método

Use para

O que uma execução cobra

Custo de exemplo por execução

SELECT DISTINCT

Só cópias exatas

Colunas lidas da tabela inteira

US$ 3,05

ROW_NUMBER() + QUALIFY

Várias versões de um registro

Mesmas colunas, mesmos bytes que o DISTINCT

US$ 3,05

MERGE (update + insert)

Manter uma tabela limpa atualizada

Lote + colunas lidas do destino + tabela de destino inteira

US$ 1,28

MERGE (só insert)

Registros que nunca mudam

Lote + colunas lidas do destino

US$ 0,06

Para tabelas pequenas, de poucos GiB, uma reconstrução completa com QUALIFY sai mais barata que o MERGE e é mais simples de configurar. Mas, assim que a tabela bruta fica muito maior que o novo lote, o MERGE passa a compensar.

Aqui está o resumo dos três métodos:

Reduzindo o custo com particionamento e clustering

Repare que o MERGE acima ainda paga pelos 200 GiB inteiros do destino a cada execução. Particionar a tabela limpa por data divide a tabela em blocos por dia, enquanto o clustering pela chave ordena os dados dentro de cada bloco, para que um filtro ou join pela chave possa pular blocos que não interessam.

Aqui está uma tabela limpa particionada pela data do pedido e com clustering pelo ID do pedido:

CREATE TABLE `shop.orders_p` (
order_id INT64,
order_date DATE,
status STRING,
amount NUMERIC,
updated_at TIMESTAMP
)
PARTITION BY order_date
CLUSTER BY order_id;

Uma tabela particionada só ajuda quando o MERGE diz ao BigQuery quais partições acessar. Adicionar um filtro na coluna de partição dentro da cláusula ON limita as partições que o BigQuery escaneia:

MERGE `shop.orders_p` AS t
USING `shop.orders_p_batch` AS s
ON t.order_id = s.order_id
AND t.order_date >= DATE '2026-10-01'
WHEN MATCHED AND s.updated_at > t.updated_at THEN
UPDATE SET
order_date = s.order_date,
status = s.status,
amount = s.amount,
updated_at = s.updated_at
WHEN NOT MATCHED THEN INSERT ROW;

Agora a conta cobre só as partições que o filtro mantém. Digamos que a tabela limpa de 200 GiB tem 1.000 dias de pedidos distribuídos de forma uniforme, então cada dia tem 0,2 GiB, e o filtro mantém os últimos 30 dias:

target partitions: 30 days x 0.2 GiB = 6 GiB
read: 2 GiB batch + 0.24 GiB target columns in those days = 2.24 GiB
8.24 GiB / 1,024 = 0.008 TiB x $6.25 = $0.05 per run
30 runs = $1.51 per month (down from $38.45)

Esse filtro tem um custo próprio. O pedido 2001 foi feito em setembro e pago em outubro. A atualização dele chega no lote, mas a partição de setembro está fora do filtro, então o MERGE não encontra a linha antiga. Ela cai no WHEN NOT MATCHED e é inserida como uma segunda linha:

order_id | order_date | status | amount | updated_at
---------+------------+---------+--------+------------------------
1001 | 2026-10-19 | paid | 120.00 | 2026-10-19 18:00:00 UTC
1002 | 2026-10-19 | paid | 80.00 | 2026-10-21 08:00:00 UTC
2001 | 2026-09-15 | pending | 30.00 | 2026-09-15 10:00:00 UTC
2001 | 2026-09-15 | paid | 30.00 | 2026-10-21 09:00:00 UTC

A solução é tirar a janela do próprio lote, para que ela sempre volte até o pedido mais antigo que o lote altera:

DECLARE min_date DATE DEFAULT (
SELECT MIN(order_date)
FROM `shop.orders_p_batch`
);

MERGE `shop.orders_p` AS t
USING `shop.orders_p_batch` AS s
ON t.order_id = s.order_id
AND t.order_date >= min_date
WHEN MATCHED AND s.updated_at > t.updated_at THEN
UPDATE SET
order_date = s.order_date,
status = s.status,
amount = s.amount,
updated_at = s.updated_at
WHEN NOT MATCHED THEN INSERT ROW;

Dessa vez, o pedido 2001 encontra correspondência, e a tabela fica com uma linha por pedido. Na primeira execução da query, confira os bytes processados nos detalhes do job para verificar que só uma pequena quantidade de dados foi escaneada. Isso funciona porque a data do pedido nunca muda para um mesmo pedido; já uma coluna que pode mudar, como updated_at, não é uma boa escolha de coluna de partição para o destino de um MERGE.

Mais alguns pontos de atenção:

  • O BigQuery vai escanear a tabela de destino inteira se você usar WHEN NOT MATCHED BY SOURCE, mesmo que a cláusula ON tenha um filtro. Como essa cláusula deleta do destino as linhas que não estão no lote, só a inclua se realmente precisar disso.
  • O BigQuery não sabe quantos blocos a query vai pular até a query ser executada. Por isso, o preço estimado antes de rodar a query vai ser maior do que o valor cobrado no final.

Dá para reduzir ainda mais o custo; veja o nosso guia de otimização de custos do BigQuery para mais detalhes.

Mantenha os dados brutos como estão e crie uma camada deduplicada

Apagar as duplicatas da tabela bruta pode parecer mais organizado, mas significa descartar a única versão dos dados que veio da fonte. Se houver qualquer bug na lógica de deduplicação, não sobra nada para reconstruir. É mais seguro manter a tabela bruta exatamente como foi carregada e construir a versão limpa em cima dela. Os dados passam então por dois níveis:

Essa é a divisão entre bronze e silver da arquitetura medallion. A camada bronze guarda os dados como chegam da fonte, duplicatas incluídas. A deduplicação é uma das primeiras etapas da camada silver. A query com QUALIFY do Método 2 vira a definição da camada limpa:

CREATE OR REPLACE VIEW `shop.orders_clean` AS
SELECT *
FROM `shop.raw_orders`
QUALIFY ROW_NUMBER() OVER (
PARTITION BY order_id
ORDER BY updated_at DESC, _loaded_at DESC
) = 1;

Para guardar o resultado, troque CREATE OR REPLACE VIEW por CREATE OR REPLACE TABLE e rode de forma agendada. As três opções geram custo em lugares diferentes:

Camada limpa

Atualidade

Quem paga o scan

View

Sempre atual

Toda query que lê a view escaneia de novo a tabela bruta

Tabela reconstruída de forma agendada

Até a última reconstrução

A reconstrução, uma vez por execução

Tabela mantida atualizada com MERGE

Até o último lote

O MERGE, uma vez por lote

Criar uma view não custa nada. Em compensação, ela acumula cada vez mais custo conforme é lida. Usando os tamanhos da seção de custos acima, um dashboard que lê a view 20 vezes por dia com SELECT * acaba escaneando a tabela bruta de 500 GiB 20 vezes, a um custo de 20 x US$ 3,05 = US$ 61,04 por dia. Já a tabela custa US$ 3,05 por dia se for reconstruída uma vez por dia. Na leitura, só escaneamos a tabela limpa.

Uma materialized view parece ficar no meio-termo, mas materialized views não suportam window functions, então não dá para usar o padrão QUALIFY com ROW_NUMBER nelas. Materialized views não incrementais, por outro lado, suportam window functions, mas são atualizadas por completo, o que nos leva de volta ao custo de uma reconstrução.

Às vezes você não quer a versão mais recente de um registro, e sim todas as versões dele, talvez para ver como um pedido passou de pending para paid. Nesse caso, não apagamos as versões; modelamos a tabela como uma slowly changing dimension tipo 2.

Evitando duplicatas na origem

Para limpar as cópias, usamos uma estratégia diferente em cada uma das queries acima. A abordagem mais econômica é garantir que elas não sejam criadas. Isso pode ser feito com três hábitos:

  1. Torne as cargas idempotentes: uma carga idempotente produz o mesmo resultado, rode ela uma ou três vezes. É o caso de operações de MERGE pela chave, em que uma segunda execução encontra as linhas já inseridas. Em streaming, o insert ID usado nas queries mais antigas de streaming insert só oferece deduplicação de melhor esforço por até um minuto. A entrega exactly-once, por sua vez, é oferecida pela Storage Write API.
  2. Defina uma chave primária na origem: todos os métodos descritos aqui dependem de alguma coluna ou conjunto de colunas que identifique um registro de forma única. Tabelas e endpoints de API sem essa coluna são os mais difíceis de limpar, então encontre ou crie essa chave antes de os dados serem gravados.
  3. Escolha o tipo de atualização por tabela: a forma como a tabela é sincronizada define se as atualizações criam linhas novas ou substituem as antigas.

Na Erathos, nossa plataforma para carregar dados de bancos de dados e APIs em warehouses como o BigQuery, o tipo de atualização é uma configuração de cada tabela, então uma mesma conexão pode usar tipos diferentes para tabelas diferentes. Estes são os tipos de sync descritos na documentação:

Tipo de atualização

O que acontece no destino

Indicado para

Full Refresh

Lê a tabela de origem inteira e sobrescreve todos os valores no destino

Tabelas pequenas, ou tabelas sem chave ou cursor

Partial Overwrite

Insere registros novos, e os registros atualizados sobrescrevem os desatualizados

Tabelas em que você só precisa do estado atual

Partial Append

Insere todos os registros, então registros atualizados aparecem mais de uma vez

Guardar todas as mudanças e limpar depois com QUALIFY

Partial Versioned

Como o Partial Append, com uma flag que marca a versão mais recente

Guardar histórico, como em uma tabela SCD2

Os tipos parciais só carregam registros cuja coluna de cursor (por exemplo, updated_at) é maior que o último valor carregado. Eles precisam de uma chave primária e de uma coluna de cursor do tipo date/datetime. Com os tipos Partial Append e Partial Versioned, que carregam de propósito mais de uma linha por registro, a view com QUALIFY da seção anterior é a camada limpa. A Erathos descreve os três tipos parciais assim:

Um cursor pode deixar passar mudanças, como linhas deletadas, por isso a Erathos também oferece change data capture (CDC) no plano Pro. O CDC lê as mudanças do log do banco de dados, e não de uma coluna de cursor. Os prós e contras estão no nosso guia sobre sync baseada em cursor vs. change data capture. Para syncs parciais, há uma configuração "Enable Full On" que agenda um full refresh de tempos em tempos para corrigir qualquer divergência entre origem e destino.

Os retries também podem ser personalizados. Com uma estratégia de retry customizada, você escolhe o número de tentativas antes de a Erathos mostrar um erro e enviar um alerta, além do tempo de espera entre as tentativas. Você pode configurar isso no nível da conexão, para valer para todos os jobs dela, ou em um único job, caso em que a configuração do job prevalece sobre a da conexão. Retries customizados estão disponíveis nos planos Pro e Enterprise.

FAQ

O BigQuery aplica chaves primárias? Não. É possível declarar chaves primárias, mas o BigQuery só suporta constraints não aplicadas. Ele aceita duas linhas com a mesma chave.

O QUALIFY é mais barato que uma subquery com ROW_NUMBER? Não. As duas leem as mesmas colunas, cobram o mesmo número de bytes e retornam as mesmas linhas. O QUALIFY só é mais curto de escrever.

Adicionar LIMIT deixa uma query de deduplicação mais barata? Não. O preço on-demand cobra pelas colunas que a query lê, e um LIMIT não muda isso. Selecionar menos colunas ou filtrar por uma coluna de partição muda.

Por que o meu MERGE falha com "must match at most one source row for each target row"? Duas ou mais linhas da origem têm a mesma chave, e o MERGE tem uma cláusula UPDATE. Deduplique a origem usando QUALIFY dentro da cláusula USING. Veja o Método 3.

Posso usar QUALIFY em uma materialized view? Não. Materialized views padrão não suportam window functions. Use uma view comum ou uma tabela reconstruída de forma agendada.

Posso rodar MERGE no sandbox do BigQuery? Não. O sandbox do BigQuery não tem acesso a comandos DML, e o MERGE é um comando DML. Ativar o faturamento no projeto do Google Cloud tira o projeto do modo sandbox.

Devo apagar as duplicatas da tabela bruta? Não. É mais seguro manter a tabela bruta como foi carregada e construir uma view ou tabela limpa em cima dela. Se a lógica de limpeza estiver errada, você corrige e reconstrói a partir dos dados brutos.

Teste com os seus próprios dados

Duplicatas são muito mais fáceis de controlar quando cada tabela é carregada do jeito certo desde o início. Na Erathos, você escolhe o tipo de atualização e as configurações de retry para cada tabela e cada job, e o BigQuery é um dos destinos. Você pode testar a Erathos grátis por 14 dias com acesso ao plano Pro.