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

Comparer deux schémas/environnements (schema diff)

Oracle

-- Extract the schema DDL from both environments and take a text diff
-- (generate deterministic DDL with DBMS_METADATA)
EXEC DBMS_METADATA.SET_TRANSFORM_PARAM(DBMS_METADATA.SESSION_TRANSFORM,'SQLTERMINATOR',TRUE);
EXEC DBMS_METADATA.SET_TRANSFORM_PARAM(DBMS_METADATA.SESSION_TRANSFORM,'STORAGE',FALSE);
SELECT DBMS_METADATA.GET_DDL('TABLE', table_name) FROM user_tables ORDER BY table_name;
-- Spool the output to a file in both environments and compare with diff/fc.

-- Export the schema as a changelog with SQLcl's Liquibase integration:
-- SQL> lb generate-schema
-- Commercial: the Oracle SQL Developer 'Database Diff' tool is also used.

Oracle n'a pas de comparaison de schémas intégrée en une commande. La méthode courante consiste à générer un DDL déterministe des deux environnements avec DBMS_METADATA.GET_DDL (attributs STORAGE/segment désactivés) et à faire un diff texte. Pour une comparaison visuelle/automatisée, utilisez l'assistant Database Diff de SQL Developer ou SQLcl.

PostgreSQL

# Dump only the schema from both databases and diff them
pg_dump --schema-only --no-owner --no-privileges sourcedb > source_schema.sql
pg_dump --schema-only --no-owner --no-privileges targetdb  > target_schema.sql
diff -u source_schema.sql target_schema.sql

# Tool that generates applicable ALTERs: apgdiff (Another PostgreSQL Diff Tool)
# apgdiff source_schema.sql target_schema.sql > migration.sql
# Alternatives: migra, Liquibase diffChangeLog

Le plus simple est de prendre la sortie de pg_dump --schema-only dans les deux environnements et de la comparer avec diff. apgdiff et migra sont des outils qui transforment directement l'écart en instructions ALTER exécutables. Ajoutez --no-owner --no-privileges pour une sortie déterministe.

MySQL

# Schema/object comparison with MySQL Utilities (5.x):
mysqldbcompare --server1=root:password@host1 --server2=root:password@host2 \
  shop:shop --difftype=sql --run-all-tests

# Built-in method: take CREATE statements from both environments and diff them
mysqldump --no-data --skip-comments shop > source_schema.sql
# SHOW CREATE TABLE customer;  (to see a single table definition)

L'outil mysqldbcompare de MySQL Utilities signale les différences d'objets/de schéma entre deux serveurs (sous forme d'instructions applicables avec difftype=sql). La méthode sans outil consiste à prendre la sortie de mysqldump --no-data (schéma seul) ou de SHOW CREATE TABLE des deux environnements et à comparer avec diff. mysqldbcompare est désormais déprécié ; pour MariaDB/8.x, Liquibase ou Skeema est préférable.

SQL Server

-- Schema comparison/deploy report with SqlPackage (what will change before applying):
sqlpackage /Action:DeployReport /SourceFile:source.dacpac \
  /TargetConnectionString:"Server=target;Database=shop;Integrated Security=true" \
  /OutputPath:diff_report.xml

-- For data differences (row level), the tablediff utility:
tablediff -sourceserver S1 -sourcedatabase shop -sourcetable customer \
  -destinationserver S2 -destinationdatabase shop -destinationtable customer

Pour les différences de schéma, SqlPackage /Action:DeployReport renvoie sous forme de rapport XML les modifications à appliquer à la cible ; /Action:Script génère un script de diff exécutable. « Schema Compare » de Visual Studio / Azure Data Studio utilise le même moteur. Pour les différences de données au niveau ligne, il existe l'utilitaire en ligne de commande tablediff.

MongoDB

// The schema is implicit; extract and compare the field structure of both environments.
// Read the $jsonSchema validator definition (collection rules):
db.getCollectionInfos({ name: "customer" })[0].options.validator

// External tools for inferred schema comparison by sampling:
// mongodb-schema (npm) or the Compass 'Schema' tab
// Take samples with mongoexport and diff the field/type distribution of both environments.

MongoDB est sans schéma ; il n'y a pas de DDL fixe. La comparaison se fait de deux façons : comparer les règles du validateur $jsonSchema défini sur la collection (via getCollectionInfos), ou générer un schéma déduit des données avec mongodb-schema / Compass et comparer les distributions de champs et de types. Pour les index, faites un diff de la sortie de db.collection.getIndexes().

Redis

# Not applicable: Redis is a schemaless key-value store; there are no
# table/column definitions (DDL) to compare.
# Closest equivalent: compare the key space (namespace) structure
# redis-cli --scan --pattern 'customer:*' | sort > source_keys.txt

Non applicable : Redis n'a pas de notion de schéma (table/colonne/DDL), un schema diff classique ne s'applique donc pas. Si une comparaison structurelle est nécessaire, seul le motif de nommage des clés (namespace) peut être listé avec SCAN et comparé.

Elasticsearch

# Fetch the index mapping from both clusters and compare
curl -s 'http://source:9200/customer/_mapping?pretty' > source_mapping.json
curl -s 'http://target:9200/customer/_mapping?pretty'  > target_mapping.json
diff -u source_mapping.json target_mapping.json

# To compare settings as well:
# GET customer/_settings   and   GET customer/_mapping

Dans Elasticsearch, l'équivalent d'un schéma est le mapping de l'index. La méthode standard consiste à prendre la sortie de GET <index>/_mapping (et _settings si nécessaire) des deux clusters et à comparer avec diff. Les champs de mapping étant en grande partie immuables, un écart détecté peut nécessiter un nouvel index + _reindex.

Ouvrir dans DBAtlas →