DBAtlas · Atlas d'exploitation des bases de données

Vérification post-migration (nombre de lignes/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;

Le contrôle le plus rapide consiste à comparer COUNT(*) par table des deux côtés. Pour trouver les vraies différences de contenu au niveau ligne, utilisez le package DBMS_COMPARISON : il compare les tables source et cible ligne par ligne via un database link et peut signaler/résorber les écarts. Pour les checksums, une empreinte de colonne peut être calculée avec 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;

La première étape consiste à comparer count(*) sur chaque table. Pour vérifier le contenu, calculez le md5 de la représentation texte de chaque ligne, concaténez-les dans l'ordre trié et hachez de nouveau ; cela donne un checksum indépendant de l'ordre entre les deux côtés. Pour de gros volumes, calculez l'empreinte uniquement sur les colonnes modifiables/clés ; trier par PK est important pour la reproductibilité.

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)

Dans MySQL, CHECKSUM TABLE donne un checksum unique du contenu de la table ; exécutez-le sur la source et la cible et comparez (moteur/version identiques requis). Utilisez COUNT(*) pour le nombre de lignes. En production et pour la cohérence de la réplication, le standard du secteur est pt-table-checksum de Percona Toolkit ; il compare par chunks, en ligne et avec un faible impact.

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;

Dans SQL Server, l'outil officiel en ligne de commande qui trouve les différences au niveau ligne est tablediff (il signale les lignes ajoutées/modifiées et, avec l'option -f, écrit un script de correction). Pour un contrôle global rapide, CHECKSUM_AGG(BINARY_CHECKSUM(*)) donne une empreinte unique de la table ; comparez les deux côtés conjointement avec COUNT_BIG(*) (indépendant de l'ordre des lignes).

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.

Le premier contrôle consiste à comparer le nombre de documents des deux côtés avec countDocuments() (estimatedDocumentCount est rapide mais repose sur les métadonnées ; utilisez countDocuments pour un nombre exact). Pour vérifier le contenu, la commande dbHash produit une empreinte md5 au niveau collection/base ; comparez les hachages des deux environnements. Vérifiez les index séparément avec 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 {})

Dans Redis, la vérification de base consiste à comparer le nombre total de clés avec DBSIZE ; la répartition par base est affichée par INFO keyspace. Redis n'a pas de checksum de table intégré ; si une vérification exacte du contenu est nécessaire, prenez la sérialisation DUMP par clé et comparez les deux côtés (tenez compte des différences de TTL). L'outil riot compare peut aussi être utilisé.

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

Dans Elasticsearch, la vérification de base consiste à comparer le nombre de documents des deux clusters avec GET <index>/_count (_cat/indices docs.count donne aussi un résumé rapide). Basez la comparaison sur _count : _cat/indices docs.count compte au niveau Lucene (sous-documents nested inclus, par ex. un document avec deux éléments nested compte pour 3), il peut donc différer de _count. Pour vérifier le contenu, comparez en échantillonnant des documents sur le même ensemble d'_id ou via un champ de hachage.

Ouvrir dans DBAtlas →