Copiar Só as Linhas que Faltam do SQL Server para o PostgreSQL pela Linha de Comando

· 9 min de leitura · sql server para postgresql · comparar dados · linhas faltantes · linha de comando · sincronização de dados · api de jobs

Copiar Só as Linhas que Faltam do SQL Server para o PostgreSQL pela Linha de Comando

Um sistema legado guarda os chamados de atendimento no SQL Server. Uma cópia em PostgreSQL serve aos relatórios. A carga noturna parou há dois dias, e antes disso já tinha perdido algumas linhas. A cópia ficou com buracos.

Recarregar a tabela inteira não é o que você quer. Você quer olhar a última semana, achar o que falta no PostgreSQL e inserir só isso, por um script que rode agendado.

Este texto mostra como fazer isso com o dbSlice by Thinwork, no Linux e no Windows. Os mesmos dois arquivos de job rodam nos dois. Todos os comandos abaixo rodaram no nosso laboratório, e todas as saídas foram copiadas dessas execuções.

Os dados de exemplo

Uma tabela genérica, support_tickets, com 20.000 chamados inventados (um a cada 259 segundos). Cada valor é calculado a partir de ticket_id.

  • SQL Server (origem): as 20.000 linhas. Script: 01-sqlserver-source.sql.
  • PostgreSQL (destino): cerca de 19.160 linhas. Faltam os dois últimos dias e, no começo da semana, alguns chamados (ids terminados em 3) se perderam. Script: 02-postgres-target.sql.

Todos os arquivos estão num download só: copy-missing-rows-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

Um job é um arquivo JSON pequeno: origem, destino, chave e o que fazer. Ele nunca guarda senha. Aponta para perfis de conexão salvos no dbSlice (aqui, MASTER e Server-dbPostg; use os nomes dos seus).

support-tickets-check.json compara e só lê:

{
  "nome": "support-tickets-check",
  "tipo": "status",
  "origem": {
    "environment": "article",
    "db": "MASTER",
    "type": "TABLE",
    "object": "support_tickets",
    "key": "ticket_id",
    "where": "opened_at >= DATEADD(day, -7, CAST(GETDATE() AS date))"
  },
  "destino": {
    "environment": "article",
    "db": "Server-dbPostg",
    "type": "TABLE",
    "object": "support_tickets",
    "key": "ticket_id"
  },
  "pageSize": 10000
}

support-tickets-load.json é o mesmo arquivo com "tipo": "insert" e o nome support-tickets-load. Ele insere as linhas cuja chave falta no destino. Nunca atualiza nem apaga.

O where limita o que se lê da origem aos últimos 7 dias, e é escrito no SQL da origem (aqui, SQL Server).

Os dois jobs também podem ser montados na tela e salvos. A tela, a linha de comando e a API rodam o mesmo arquivo.

Rodar em três passos

No Linux, o dbSlice roda num container Docker. Coloque os dois arquivos de job na pasta jobs/ do volume de dados. No Windows, salve os dois perfis no dbSlice.

Cada passo mostra três formas de rodar. Use a API de jobs para pipelines remotos (CI, n8n, outro servidor): precisa de um token (guia API, escopos jobs:run e runs:read) e responde com um runId. Use o docker run para o cron do host do Docker: não precisa de token, espera, mostra o log e termina com um código de saída. No Windows, use a CLI e o Agendador de Tarefas para agendar.

Passo 1. Comparar (só leitura)

Linux — jobs API (curl)

URL=http://127.0.0.1:8098
TOKEN="$(cat ./token)"   # dbs_xxxxxxxx_...
curl -sS -X POST "$URL/api/v1/jobs/support-tickets-check/run" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"runLabel":"last-week"}'

A resposta é 202 com um runId. Consulte a execução até o status sair de queued e running, e então 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"

O token é lido de um arquivo para não aparecer no histórico do shell. O run-linux.sh, ao lado deste artigo, faz a sequência inteira.

Linux — docker run

docker run --rm --network dbslice-web_default \
  -v /docker/data/dbslice-web:/data -v /docker/data/dbslice-web-logs:/logs \
  dbslice-web --run support-tickets-check

O --network só é preciso quando os bancos são acessados pelo nome de outro container. Com o container já no ar, fica mais curto:

docker exec dbslice-web dotnet DBSlice.UiWeb.dll --run support-tickets-check

Os dois rodam o job do mesmo jeito que a tela e a API. Cada execução grava também o log em /logs. Dá para rodar com o container web no ar.

Windows — dbSlice.exe

dbSlice.exe support-tickets-check.json check.log

A CLI mostra o resultado e grava o log no arquivo indicado. Sai com 0 quando dá certo e diferente de zero quando não dá.

Saída no Linux (docker exec … --run support-tickets-check). O laboratório rodou em inglês, então as linhas de log estão em inglês:

[05:29:45] INFO  impact: read-only, nothing is written to a database
[05:29:46] INFO  OK  Comparison completed in 1.3s: 1,570 matched, 842 missing in destination, 17,588 missing in source. 0 with different column values.
[05:29:46] OK    Status OK | MASTER -> Server-dbPostg | 2,412 Rows | 1.4s
log: /logs/20261118-052945-job-support-tickets-check-f87239f8.log
exit code: 3

Código 3: faltam linhas (842 faltando no destino).

O código de saída diz ao cron o que aconteceu:

CódigoSignificado
0OK. Na comparação: nada faltando, nada diferente
1O job falhou
2Argumento errado, job inexistente ou bloqueado pela licença
3A comparação achou linhas faltando ou diferentes

Passo 2. Inserir só as linhas que faltam

Linux — jobs API (curl)

Chame o mesmo endereço com support-tickets-load:

curl -sS -X POST "$URL/api/v1/jobs/support-tickets-load/run" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"runLabel":"last-week"}'

Linux — docker run

docker run --rm --network dbslice-web_default \
  -v /docker/data/dbslice-web:/data -v /docker/data/dbslice-web-logs:/logs \
  dbslice-web --run support-tickets-load

Windows — dbSlice.exe

dbSlice.exe support-tickets-load.json load.log

Saída no Linux (docker run … --run support-tickets-load):

[05:29:47] INFO  impact: writes to the target (INSERT only)
[05:29:49] INFO  OK  Done: 2,412 read, 842 inserted, 0 upsert/update in 1.5s  ·  read 0.1s / transform 0.1s / write 0.4s
exit code: 0

Passo 3. Comparar de novo

Linux — jobs API (curl)

curl -sS -X POST "$URL/api/v1/jobs/support-tickets-check/run" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"runLabel":"last-week"}'

Linux — docker run

docker run --rm --network dbslice-web_default \
  -v /docker/data/dbslice-web:/data -v /docker/data/dbslice-web-logs:/logs \
  dbslice-web --run support-tickets-check

Windows — dbSlice.exe

dbSlice.exe support-tickets-check.json check.log

Saída no Linux:

[05:29:52] INFO  OK  Comparison completed in 1.3s: 2,412 matched, 0 missing in destination, 17,588 missing in source. 0 with different column values.
exit code: 0

Saída no Windows, comparação e insert:

OK  Comparison completed in 5.4s: 1,561 matched, 841 missing in destination, 17,598 missing in source. 0 with different column values.
OK  Done: 2,402 read, 841 inserted, 0 upsert/update in 0.7s

O Windows achou 841 e o Linux 842 porque as execuções foram em horas diferentes do dia, e a janela de 7 dias anda com o relógio.

Por que "missing in source" é tão grande

Cerca de 17.600 chaves aparecem como "faltando na origem". Isso é esperado. O where filtra só a origem, então a origem traz apenas os últimos 7 dias, enquanto o PostgreSQL guarda também o histórico mais antigo. O número que importa é faltando no destino. O código de saída segue a mesma regra: quando o job tem where, linha que só existe no destino não conta como diferença.

Pode rodar de novo

Depois do insert, uma segunda execução de cada job achou 0 faltando e inseriu 0 linhas. O PostgreSQL chegou a 20.000 linhas, igual à origem. Uma execução sem nada a fazer não mexe em nada, então dá para agendar o insert sem criar duplicatas. Com esses dados, cada execução levou menos de 6 segundos.

Agendar

Linux (cron no host do Docker), toda noite às 02:00, sem script intermediário:

0 2 * * * docker run --rm --network dbslice-web_default -v /docker/data/dbslice-web:/data -v /docker/data/dbslice-web-logs:/logs dbslice-web --run support-tickets-load >> /var/log/support-tickets.log 2>&1

Para ser avisado das linhas que faltam em vez de corrigir, agende o support-tickets-check e dispare o alerta no código 3.

Windows (Agendador de Tarefas): crie uma tarefa que rode dbSlice.exe support-tickets-load.json load.log. Execução com falha aparece como tarefa com falha.

A série

Este texto veio primeiro. A série "dbSlice CLI no dia a dia" continua com quatro casos:

  1. Conferir e Completar uma Migração Grande do SQL Server para o PostgreSQL pela Linha de Comando
  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

Fechamento

Dois arquivos JSON pequenos, um de comparação e outro de insert, resolvem o caso "copiar só o que falta". No Linux, rode pela API de qualquer lugar ou pelo docker run no cron. No Windows, pelo dbSlice.exe. O job nunca leva senha.

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