Uma tabela grande foi carregada do SQL Server para o PostgreSQL. A carga terminou, mas você ainda não confia nela. Parou antes do fim? E a origem continuou recebendo gravações durante a carga: essas linhas foram copiadas com os valores antigos?
São duas respostas. Primeiro, o que difere entre origem e destino. Segundo, como corrigir sem recarregar a tabela. E das duas por script, para rodar no cron ou no CI.
Este texto mostra como fazer, no Linux e no Windows, com o dbSlice by Thinwork. Os mesmos dois arquivos de job rodam nos dois. Todas as saídas abaixo vêm de execuções reais.
Os dados de exemplo
Uma tabela genérica, orders: 50.000 linhas, sem dado real. Cada valor é calculado a partir de order_id.
- SQL Server (origem): as 50.000 linhas. Veja
01-sqlserver-source.sql. - PostgreSQL (destino): 48.800 linhas, com os dois problemas comuns depois de uma carga grande. Veja
02-postgres-target.sql. - A carga parou antes do fim: os pedidos 48.801 a 50.000 não chegaram (1.200 linhas).
- A origem seguiu em uso durante a carga: 305 pedidos mudaram de status e de valor depois de copiados, então o destino guarda os valores antigos.
Todos os arquivos estão num download só: migration-reconcile-sqlserver-postgresql.zip. Ele traz os dois scripts SQL, os dois arquivos de job e um script pronto para Linux (run-linux.sh) e para Windows (run-windows.ps1). Os comentários dos arquivos estão em inglês.
Os dois arquivos de job
O job é um JSON pequeno com origem, destino, chave e modo. Ele nunca leva senha: só o nome de um perfil de conexão que você salvou no dbSlice.
MASTER e Server-dbPostg são os nomes dos perfis do nosso laboratório. Troque pelos nomes dos seus perfis.
O primeiro job, migration-orders-check.json, compara e só lê:
{
"nome": "migration-orders-check",
"tipo": "status",
"origem": {
"environment": "article",
"db": "MASTER",
"type": "TABLE",
"object": "orders",
"key": "order_id"
},
"destino": {
"environment": "article",
"db": "Server-dbPostg",
"type": "TABLE",
"object": "orders",
"key": "order_id"
},
"pageSize": 10000
}
O segundo, migration-orders-fix.json, tem a mesma origem e o mesmo destino. Troca "tipo" para "sync" e acrescenta o modo:
{
"nome": "migration-orders-fix",
"tipo": "sync",
"mode": "Upsert",
...
}
O Upsert insere as linhas cuja chave falta no destino e atualiza as que já existem. Nunca apaga.
Também dá para montar a comparação ou a sincronização na tela (Comparar dados / Sincronizar), salvar e apontar um job para o arquivo salvo: a CLI e a API rodam exatamente o que a tela roda.
Como rodar: Linux e Windows
| Linux (edição Docker, API de jobs) | Windows (CLI) |
|---|---|
Precisa de curl e jq. Crie um token na guia API da edição web, com os escopos jobs:run e runs:read, a lista de jobs permitidos e a validade. Salve em um arquivo. Copie os dois arquivos de job para a pasta jobs/ do volume de dados da instância. A API roda o job pelo nome. | Salve os dois perfis no dbSlice. Não há mais nada para configurar. |
O token vai só no cabeçalho Authorization: Bearer. | O job não leva token nem senha. |
A sequência é: comparar, corrigir, comparar de novo, corrigir de novo.
Passo 1. Comparar (só leitura)
Linux:
URL=http://127.0.0.1:8098
TOKEN="$(cat ./token)" # dbs_xxxxxxxx_...
curl -sS -X POST "$URL/api/v1/jobs/migration-orders-check/run" \
-H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-d '{"runLabel": "after-migration"}'
Windows:
dbSlice.exe migration-orders-check.json check.log
Passo 2. Corrigir (Upsert)
Linux:
curl -sS -X POST "$URL/api/v1/jobs/migration-orders-fix/run" \
-H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-d '{"runLabel": "after-migration"}'
Windows:
dbSlice.exe migration-orders-fix.json fix.log
Passo 3. Ler o resultado
Linux: a API responde com um runId. Consulte a execução até o status sair de queued e running, e leia o log.
curl -sS -H "Authorization: Bearer $TOKEN" "$URL/api/v1/runs/<runId>"
curl -sS -H "Authorization: Bearer $TOKEN" "$URL/api/v1/runs/<runId>/log"
Windows: a CLI imprime o resultado e grava o log no arquivo informado.
Nos dois sistemas o código de saída diz se a execução deu certo. No Windows é 0 em caso de sucesso e diferente de zero se falhar. No Linux, faça o script sair com código diferente de zero quando a execução não terminar em succeeded. É o que o cron ou o CI precisam para perceber uma execução com falha.
O que a primeira comparação mostra
Saída no Linux (a instância do laboratório roda em português):
Comparação concluída em 1,0s: 48.495 iguais, 1.200 faltando no destino, 0 faltando na origem. 305 com valores divergentes.
Faltando no destino (1.200): 48801, 48802, 48803, ...
160: amount [69.2 ≠ 64.2], status [shipped ≠ pending]
320: amount [128.4 ≠ 123.4], status [shipped ≠ pending]
...
No Windows, o mesmo resultado (interface em inglês): 48,495 matched, 1,200 missing in destination, 0 missing in source. 305 with different column values.
Leia em três grupos:
- 1.200 faltando no destino: a carga parou em 48.800.
- 0 faltando na origem: nada existe só no destino.
- 305 com valores divergentes: o log lista cada chave e as colunas que diferem, com o valor da origem primeiro. Aqui a origem diz
shippede o destino ainda dizpending.
Corrigir com um Upsert
Saída no Linux:
Concluído: 50.000 lidos, 1.200 inseridos, 48.800 upsert/update em 2,6s
O Windows deu as mesmas contagens: 50,000 read, 1,200 inserted, 48,800 upsert/update.
Os 1.200 inseridos são as linhas que não chegaram. As 305 linhas desatualizadas estão entre as 48.800 que passaram por upsert/update.
A prova: comparar de novo
Comparação concluída em 0,7s: 50.000 iguais, 0 faltando no destino, 0 faltando na origem. 0 com valores divergentes.
O PostgreSQL passou de 48.800 para 50.000 linhas, e as linhas desatualizadas passaram de 305 para 0. Quem prova que acabou é a comparação. Não use só os contadores do próprio job de correção para isso.
Rodar a correção duas vezes
Rodamos o job de correção uma segunda vez:
Concluído: 50.000 lidos, 0 inseridos, 50.000 upsert/update em 2,2s
Leia com honestidade. 0 inseridos está certo: nada faltava. Mas 50.000 upsert/update significa que o Upsert regravou todas as linhas que casaram. Ele não pula as que já estão iguais. O resultado é idempotente, porque os valores gravados são os mesmos que já estavam, então nada muda. Mas o trabalho não é zero.
Por isso a prova de que acabou é a segunda comparação, com 0 / 0 / 0, e não uma segunda correção que parece quieta.
Tabela muito grande: limite a janela
Se a tabela tem centenas de milhões de linhas, você não quer regravar tudo a cada execução. Coloque um where na origem do job de correção e limite ao que pode ter mudado, por exemplo o período em que a origem esteve em uso durante a migração:
"origem": {
"environment": "article",
"db": "MASTER",
"type": "TABLE",
"object": "orders",
"key": "order_id",
"where": "ordered_at >= '2025-06-01'"
}
O where usa o dialeto da origem (SQL Server). Um detalhe: ele filtra só a leitura da origem. Se você puser o mesmo where no job de comparação, as linhas fora da janela continuam no PostgreSQL, e a comparação as mostra como faltando na origem. Não é erro. Só quer dizer que elas estão fora da janela. Olhe faltando no destino e divergentes dentro da janela. Com esse where, nos mesmos dados de exemplo, a comparação leu 25.841 linhas da origem e deu 24.486 iguais, 1.200 faltando no destino, 155 divergentes e 24.159 faltando na origem (as linhas do PostgreSQL de antes de junho de 2025).
No Linux o where também pode ir no corpo do POST, e um só arquivo de job atende várias janelas. O corpo aceita só where, file, pageSize, confirmProduction e runLabel. Conexões e senhas nunca viajam no corpo.
Agendar
Linux (cron), toda noite às 02:00. Guarde os quatro passos num script que sai com erro quando falha:
0 2 * * * /opt/jobs/reconcile.sh >> /var/log/reconcile.log 2>&1
Windows (Agendador de Tarefas): crie uma tarefa que roda dbSlice.exe migration-orders-fix.json fix.log. O Agendador lê o código de saída, então uma execução com falha aparece como tarefa com falha.
A série
"dbSlice CLI no dia a dia", quatro casos pela linha de comando:
- Conferir e Completar uma Migração Grande do SQL Server para o PostgreSQL pela Linha de Comando (este texto)
- Colocar em Dia uma Réplica PostgreSQL Depois de uma Queda de Rede, pela Linha de Comando
- Corrigir Chaves Estrangeiras Quebradas Depois de Mensagens Perdidas na Fila, pela Linha de Comando
- Monte uma Base de QA Mascarada a partir de uma Amostra da Produção, pela Linha de Comando
Também pela linha de comando: Copiar Só as Linhas que Faltam do SQL Server para o PostgreSQL pela Linha de Comando.
Fechamento
Dois arquivos JSON pequenos, um de comparação e outro de Upsert, resolvem o caso "conferir a migração e completar o que falta". A comparação mostra o que faltou e o que divergiu. O Upsert corrige os dois. A segunda comparação, com zero em tudo, é a prova. Rodam no terminal, no cron, no Agendador ou pela API. O job nunca leva senha.
Se você só precisa copiar as linhas que faltam, sem atualizar nada, veja Copiar só as linhas que faltam do SQL Server para o PostgreSQL pela linha de comando.
O dbSlice é produto da nossa empresa, então leia com isso em mente. Para testar:
- Windows: dbSlice na Microsoft Store. Veja o que o app para Windows faz.
- Edição Linux / Docker: é corporativa, por contato. Escreva para contact@dbslice.net. Veja o que a edição Linux faz.


