Conferir e Completar uma Migração Grande do SQL Server para o PostgreSQL pela Linha de Comando

· 9 min de leitura · sql server para postgresql · migração de dados · comparar dados · upsert · linha de comando · api de jobs

Conferir e Completar uma Migração Grande do SQL Server para o PostgreSQL pela Linha de Comando

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 shipped e o destino ainda diz pending.

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:

  1. Conferir e Completar uma Migração Grande do SQL Server para o PostgreSQL pela Linha de Comando (este texto)
  2. Colocar em Dia uma Réplica PostgreSQL Depois de uma Queda de Rede, pela Linha de Comando
  3. Corrigir Chaves Estrangeiras Quebradas Depois de Mensagens Perdidas na Fila, pela Linha de Comando
  4. 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:

Experimente grátis na Microsoft Store ↗ Ver preços

← Voltar ao blog