DBAtlas · Atlas de operações de banco de dados

Verificação pós-migração (contagem de linhas/checksum)

Oracle

-- Compare row counts on source and target
SELECT 'customer' table_name, COUNT(*) row_count FROM customer;

-- To find content differences at object level, DBMS_COMPARISON (via db link)
BEGIN DBMS_COMPARISON.CREATE_COMPARISON(
  comparison_name => 'COMPARE_CUSTOMER',
  schema_name => 'SHOP', object_name => 'CUSTOMER',
  dblink_name => 'TARGET_DB'); END;
/
-- SELECT DBMS_COMPARISON.COMPARE('COMPARE_CUSTOMER', scan_info) FROM dual;

A verificação mais rápida é comparar COUNT(*) por tabela nos dois lados. Para encontrar diferenças reais de conteúdo em nível de linha, use o package DBMS_COMPARISON: ele compara as tabelas de origem e destino linha a linha por um database link e pode informar/convergir as diferenças. Para checksums, pode-se obter um digest de colunas com ORA_HASH ou STANDARD_HASH.

PostgreSQL

-- Row count
SELECT count(*) FROM customer;

-- Ordered digest (checksum) of the whole table content — compare on both sides
SELECT md5(string_agg(t.row_md5, '' ORDER BY t.row_md5)) AS digest
FROM (SELECT md5(customer::text) AS row_md5 FROM customer) t;

O primeiro passo é comparar count(*) em cada tabela. Para verificação de conteúdo, calcule o md5 da representação textual de cada linha, concatene-os em ordem e aplique o hash novamente; isso fornece um checksum independente de ordem entre os dois lados. Para grandes volumes, calcule o digest apenas sobre as colunas mutáveis/chave; ordenar pela PK é importante para a repetibilidade.

MySQL

-- Built-in table checksum (run on both servers and compare)
CHECKSUM TABLE customer;

-- Row count
SELECT COUNT(*) FROM customer;

-- Preferred tool for live/large environments (compares row chunks online):
-- pt-table-checksum h=source,D=shop  (Percona Toolkit)

No MySQL, CHECKSUM TABLE fornece um único checksum do conteúdo da tabela; execute-o na origem e no destino e compare (engine/versão devem ser os mesmos). Use COUNT(*) para a contagem de linhas. Em produção e para consistência da replicação, o padrão do mercado é o pt-table-checksum do Percona Toolkit; ele compara chunk a chunk, online e com baixo impacto.

SQL Server

-- Full row-level comparison (official tool that produces differences)
tablediff -sourceserver S1 -sourcedatabase shop -sourcetable customer \
  -destinationserver S2 -destinationdatabase shop -destinationtable customer

-- Quick aggregate checksum (single query, compare on both sides):
SELECT COUNT_BIG(*) row_count, CHECKSUM_AGG(BINARY_CHECKSUM(*)) digest FROM dbo.customer;

No SQL Server, a ferramenta oficial de linha de comando que encontra diferenças em nível de linha é o tablediff (informa quais linhas foram adicionadas/alteradas e, com o -f opcional, grava um script de correção). Para uma verificação geral rápida, CHECKSUM_AGG(BINARY_CHECKSUM(*)) fornece um único digest da tabela; compare os dois lados junto com COUNT_BIG(*) (independente da ordem das linhas).

MongoDB

// Compare document counts (on source and target)
db.customer.countDocuments({});

// For a content checksum, dbHash (md5 digest at collection/DB level):
db.runCommand({ dbHash: 1, collections: ["customer"] });
// -> compare the md5 field across both environments.

A primeira verificação é comparar a contagem de documentos nos dois lados com countDocuments() (estimatedDocumentCount é rápido, mas depende de metadados; use countDocuments para uma contagem exata). Para verificação de conteúdo, o comando dbHash gera um digest md5 em nível de coleção/banco; compare os hashes dos dois ambientes. Verifique os índices separadamente com getIndexes().

Redis

# Compare key counts (on source and target)
redis-cli DBSIZE

# For a memory/data summary and key distribution:
redis-cli INFO keyspace     # db0:keys=... information
# For full content verification: DUMP each key and compare with the target
# (e.g. redis-cli --scan | xargs -I{} redis-cli DUMP {})

No Redis, a verificação básica é comparar a contagem total de chaves com DBSIZE; a distribuição por banco é mostrada por INFO keyspace. O Redis não tem checksum de tabela nativo; se for necessária verificação exata de conteúdo, obtenha a serialização DUMP por chave e compare os dois lados (lembre-se das diferenças de TTL). A ferramenta riot compare também pode ser usada.

Elasticsearch

# Compare document counts (on source and target clusters)
GET customer/_count

# Details: for health/segment/storage comparison
GET _cat/indices/customer?v&h=index,docs.count,store.size
# Content by sampling: compare GET customer/_doc/<id> for the same _ids

No Elasticsearch, a verificação básica é comparar a contagem de documentos nos dois clusters com GET <index>/_count (o docs.count de _cat/indices também fornece um resumo rápido). Baseie a comparação em _count: o docs.count de _cat/indices conta no nível do Lucene (incluindo subdocumentos nested; ex.: um documento com dois itens nested conta como 3), então pode diferir de _count. Para verificação de conteúdo, compare por amostragem de documentos sobre o mesmo conjunto de _ids ou por um campo de hash.

Abrir no DBAtlas →