Red Gate SQL comparer produit non seulement vous permet de faire des comparaisons au niveau de l'objet, et de générer des scripts de changement à partir de cela, mais il vous permet également d'exporter vos objets de base de données dans une hiérarchie de dossiers organisés par type d'objet, avec un [objectname].script de création sql par objet dans ces répertoires. La hiérarchie objet-type est comme ceci:

\fonctions

\Security

\Security\Rôles

\Security\Schémas

\Security\Users

\Procédures Stockées

\Tables

si vous dumpez vos scripts dans le même répertoire racine après avoir fait des modifications, vous pouvez utiliser cette option pour mettre à jour votre SVN repo, et garder un historique de fonctionnement de chaque objet individuellement.

il s'agit d'un des" problèmes difficiles " entourant le développement. Autant que je sache, il n'y a pas de solutions parfaites.

si vous n'avez besoin que de stocker la structure de la base de données et non les données, vous pouvez exporter la base de données sous forme de requêtes SQL. (dans Enterprise Manager: clic droit sur la base de données -> générer un script SQL. Je recommande de paramétrer" créer un fichier par objet " dans l'onglet options. vous pouvez ensuite propager ces fichiers texte vers svn et utiliser la différence et la journalisation de svn. fonction.

j'ai ceci lié avec un script de lot qui prend quelques paramètres et met en place la base de données. J'ai aussi ajouté quelques requêtes supplémentaires qui saisissent des données par défaut comme les types d'utilisateurs et l'utilisateur administrateur. (Si vous voulez plus d'informations à ce sujet, postez quelque chose et je peux mettre le script quelque part accessible)

si vous avez besoin de conserver toutes les données aussi bien, je recommande de garder une sauvegarde de la base de données et en utilisant Redgate ( http://www.red-gate.com / ) produits pour faire les comparaisons. Ils ne sont pas bon marché, mais ils valent chaque centime.

tout d'abord, vous devez choisir le système de contrôle de version qui vous convient:

• "151900920 Centralisée, système de Contrôle de Version - un système standard où les utilisateurs check-out/check-in avant/après, ils travaillent sur des fichiers et les fichiers sont gardés dans un seul serveur central

• Distributed Version Control system - un système où le référentiel est en cours de duplication, et chaque clone est en fait la sauvegarde complète de le référentiel, donc si un serveur tombe en panne, puis clonés tout référentiel peut être utilisé pour restaurer Après avoir choisi le bon système pour vos besoins, vous aurez besoin de configurer le référentiel qui est le cœur de chaque système de contrôle de version Tout cela est expliqué dans l'article suivant: http://solutioncenter.apexsql.com/sql-server-source-control-part-i-understanding-source-control-basics/

dans le cas d'un système central de contrôle de version un dossier de travail, vous pouvez lire cet article . Il montre comment configurer le contrôle source dans un environnement de développement en utilisant:

• SQL Server Management Studio via le fournisseur MSSCCI,

• Visual Studio and SQL Server Data Tools

• a third party tool ApexSQL Source Control

ici à Red Gate nous offrons un outil, SQL Source Control , qui utilise la technologie SQL Comparer pour relier votre base de données avec un TFS ou un dépôt SVN. Cet outil s'intègre dans SSMS et vous permet de travailler comme vous le feriez normalement, sauf qu'il vous permet désormais d'engager les objets.

pour une approche basée sur les migrations (plus adapté aux déploiements automatisés), nous offrons ReadyRoll , qui crée et gère un ensemble de scripts incrémentiels comme un projet de studio visuel.

dans le contrôle source SQL il est possible de spécifier des tables de données statiques. Ceux-ci sont stockés dans le contrôle source sous forme D'instructions INSERT.

si vous parlez de données de test, nous vous recommandons soit de générer des données de test avec un outil ou via un script de post-déploiement que vous avez défini, soit de simplement restaurer une sauvegarde de production dans l'environnement dev.

vous pourriez vouloir regarder Liquibase ( ) http://www.liquibase.org / ). Même si vous n'utilisez pas l'outil lui-même, il gère assez bien les concepts de gestion des modifications ou de refonte de la base de données.

+1 pour tous ceux qui ont recommandé les outils RedGate, avec une recommandation supplémentaire et une mise en garde.

SqlCompare a aussi une API correctement documentée: ainsi, vous pouvez, par exemple, écrire une application de console qui synchronise votre dossier de scripts contrôlés par source avec une base de données de test D'intégration CI sur checkin, de sorte que lorsque quelqu'un vérifie une modification au schéma à partir de leur dossier de scripts il est automatiquement déployé avec le changement de code d'application correspondant. Ce aide à combler l'écart avec les développeurs qui sont incapables de propager des changements dans leur base de données locale jusqu'à une base de données de développement partagée (environ la moitié d'entre nous, je pense :) ).

une mise en garde est qu'avec une solution scriptée ou autre, les outils RedGate sont suffisamment lisses pour qu'il soit facile d'oublier les réalités SQL sous-jacentes à l'abstraction. Si vous renommez toutes les colonnes d'une table, SqlCompare n'a aucun moyen de mapper les anciennes colonnes aux nouvelles colonnes et laissera tomber toutes les données dans le table. Il va générer des avertissements, mais j'ai vu des gens sur le passé. Il y a ici un point général qui vaut la peine d'être souligné, je pense, que vous ne pouvez automatiser le versioning et la mise à niveau de la base de données que jusqu'à présent - les abstractions sont très perméables.

nous utilisons DBGhost pour gérer notre base de données SQL. Ensuite, vous mettez vos scripts pour construire une nouvelle base de données dans votre contrôle de version, et il sera soit construire une nouvelle base de données, ou mettre à niveau n'importe quelle base de données existante pour le schéma dans le contrôle de version. De cette façon, vous n'avez pas à vous soucier de créer des scripts de modification (bien que vous puissiez encore le faire, si par exemple vous voulez changer le type de données d'une colonne et avez besoin de convertir des données).

avec VS 2010, utilisez le projet de base de données.

1. Script de votre base de données
2. apporte des modifications aux scripts ou directement sur votre serveur db
3. Synchroniser à l'aide de Données > Comparaison Du Schéma 151940920"

fait une solution parfaite DB versioning, et rend la synchronisation DB's un jeu d'enfant.

c'est une bonne approche pour sauver des scripts de base de données dans le contrôle de version avec des scripts de changement afin que vous puissiez mettre à jour n'importe quelle base de données que vous avez. Vous pouvez également enregistrer des schémas pour différentes versions afin de créer une base de données complète sans avoir à appliquer tous les scripts de modification. La manipulation des scripts devrait être automatisée afin que vous n'ayez pas à faire de travail manuel.

je pense qu'il est important d'avoir une base de données séparée pour chaque développeur et de ne pas utiliser un base de données partagée. De cette façon, les développeurs peuvent créer des cas de test et des phases de développement indépendamment des autres développeurs.

l'outil d'automatisation devrait disposer de moyens pour traiter les métadonnées des bases de données, qui indiquent quelles bases de données se trouvent dans quel état de développement et quelles tables contiennent des données contrôlables de version et ainsi de suite.

vous n'avez pas mentionné de détails au sujet de votre environnement cible ou de vos contraintes, il se peut donc que cela ne soit pas entièrement applicable... mais si vous êtes à la recherche d'un moyen efficace de suivre un schéma de base de données en évolution et que vous n'êtes pas contre L'idée d'utiliser Ruby, les migrations D'ActiveRecord sont tout à fait dans vos cordes.

Migrations programatiquement définir les transformations de base de données à l'aide D'un Ruby DSL; chaque transformation peut être appliquée ou (habituellement) retravaillée, vous permettant de sauter à un version différente de votre schéma de base de données à un moment donné. Le fichier définissant ces transformations peut être vérifié dans le contrôle de version comme n'importe quel autre morceau de code source.

parce que les migrations font partie de ActiveRecord , ils trouvent généralement l'utilisation dans les applications de Rails full-stack; cependant, vous pouvez utiliser ActiveRecord indépendant des Rails avec un effort minimal. Voir ici pour un traitement plus détaillé de l'utilisation des migrations D'AR à l'extérieur des Rails.

vous pouvez également regarder une solution de migrations. Ceux-ci vous permettent de spécifier votre schéma de base de données dans le code C#, et de rouler votre version de base de données de haut en bas en utilisant MSBuild.

j'utilise actuellement DbUp , et ça marche bien.

chaque base de données doit être sous contrôle de code source. Ce qui fait défaut, c'est un outil permettant de configurer automatiquement tous les objets de la base de données - et les "données de configuration" - en fichiers, qui peuvent ensuite être ajoutés à n'importe quel système de contrôle source. Si vous utilisez SQL Server, alors ma solution est ici: http://dbsourcetools.codeplex.com / . Amuser. - Nathan.

c'est simple.

1. lorsque le projet de base est prêt, vous devez créer le script complet de la base de données. Ce script est redirigé vers SVN. C'est la première version.

2. après que tous les développeurs créent des scripts de modification (ALTER..., nouveaux tableaux, sprocs, etc.).

3. lorsque vous avez besoin de la version actuelle, vous devez exécuter tous les nouveaux scripts de modification.

4. quand app est sorti en production alors vous retournez à 1 (mais alors ce sera version successive bien sûr).

Nant vous aidera à exécuter ces scripts de modification. :)

et rappelez-vous. Tout fonctionne bien quand il y a de la discipline. Chaque fois que la modification de la base de données est commitée, les fonctions correspondantes dans le code sont également commutées.

si vous avez une petite base de données et que vous voulez faire une version complète, ce script de traitement par lots pourrait vous aider. Il décompresse, comprime et vérifie un fichier MDF de la base de données MSSQL dans Subversion.

si vous voulez principalement modifier votre schéma et juste avoir une petite quantité de données de référence, vous pouvez éventuellement utiliser migrations subsoniques pour gérer cela. L'avantage est que vous pouvez facilement migrer vers le haut ou vers le bas version.

pour faire le dump vers un système de contrôle de code source un peu plus rapide, vous pouvez voir quels objets ont changé depuis la dernière fois en utilisant les informations de version dans sysobjects.

Setup: créer une table dans chaque base de données que vous voulez vérifier progressivement pour conserver les informations de version de la dernière fois que vous l'avez cochée (vide sur la première exécution). Supprimez ce tableau si vous souhaitez numériser à nouveau l'ensemble de votre structure de données.

IF ISNULL(OBJECT_ID('last_run_sysversions'), 0) <> 0 DROP TABLE last_run_sysversions
CREATE TABLE last_run_sysversions (
    name varchar(128), 
    id int, base_schema_ver int,
    schema_ver int,
    type char(2)
)

mode d'exécution Normal: vous pouvez prendre les résultats de ce sql, et générer des scripts sql pour ceux qui vous intéressent, et les mettre dans un contrôle source de votre choix.

IF ISNULL(OBJECT_ID('tempdb.dbo.#tmp'), 0) <> 0 DROP TABLE #tmp
CREATE TABLE #tmp (
    name varchar(128), 
    id int, base_schema_ver int,
    schema_ver int,
    type char(2)
)

SET NOCOUNT ON

-- Insert the values from the end of the last run into #tmp
INSERT #tmp (name, id, base_schema_ver, schema_ver, type) 
SELECT name, id, base_schema_ver, schema_ver, type FROM last_run_sysversions

DELETE last_run_sysversions
INSERT last_run_sysversions (name, id, base_schema_ver, schema_ver, type)
SELECT name, id, base_schema_ver, schema_ver, type FROM sysobjects

-- This next bit lists all differences to scripts.
SET NOCOUNT OFF

--Renamed.
SELECT 'renamed' AS ChangeType, t.name, o.name AS extra_info, 1 AS Priority
FROM sysobjects o INNER JOIN #tmp t ON o.id = t.id
WHERE o.name <> t.name /*COLLATE*/
AND o.type IN ('TR', 'P' ,'U' ,'V')
UNION 

--Changed (using alter)
SELECT 'changed' AS ChangeType, o.name /*COLLATE*/, 
       'altered' AS extra_info, 2 AS Priority
FROM sysobjects o INNER JOIN #tmp t ON o.id = t.id 
WHERE (
   o.base_schema_ver <> t.base_schema_ver
OR o.schema_ver      <> t.schema_ver
)
AND  o.type IN ('TR', 'P' ,'U' ,'V')
AND  o.name NOT IN ( SELECT oi.name 
         FROM sysobjects oi INNER JOIN #tmp ti ON oi.id = ti.id
         WHERE oi.name <> ti.name /*COLLATE*/
         AND oi.type IN ('TR', 'P' ,'U' ,'V')) 
UNION

--Changed (actually dropped and recreated [but not renamed])
SELECT 'changed' AS ChangeType, t.name, 'dropped' AS extra_info, 2 AS Priority
FROM #tmp t
WHERE    t.name IN ( SELECT ti.name /*COLLATE*/ FROM #tmp ti
         WHERE NOT EXISTS (SELECT * FROM sysobjects oi
                           WHERE oi.id = ti.id))
AND  t.name IN ( SELECT oi.name /*COLLATE*/ FROM sysobjects oi
         WHERE NOT EXISTS (SELECT * FROM #tmp ti
                           WHERE oi.id = ti.id)
         AND   oi.type  IN ('TR', 'P' ,'U' ,'V'))
UNION

--Deleted
SELECT 'deleted' AS ChangeType, t.name, '' AS extra_info, 0 AS Priority
FROM #tmp t
WHERE NOT EXISTS (SELECT * FROM sysobjects o
                  WHERE o.id = t.id)
AND t.name NOT IN (  SELECT oi.name /*COLLATE*/ FROM sysobjects oi
         WHERE NOT EXISTS (SELECT * FROM #tmp ti
                           WHERE oi.id = ti.id)
         AND   oi.type  IN ('TR', 'P' ,'U' ,'V'))
UNION

--Added
SELECT 'added' AS ChangeType, o.name /*COLLATE*/, '' AS extra_info, 4 AS Priority
FROM sysobjects o
WHERE NOT EXISTS (SELECT * FROM #tmp t
                  WHERE o.id = t.id)
AND      o.type  IN ('TR', 'P' ,'U' ,'V')
AND  o.name NOT IN ( SELECT ti.name /*COLLATE*/ FROM #tmp ti
         WHERE NOT EXISTS (SELECT * FROM sysobjects oi
                           WHERE oi.id = ti.id))
ORDER BY Priority ASC

Note: si vous utilisez une compilation non standard dans l'une de vos bases de données, vous devrez remplacer /* COLLATE */ par la compilation de votre base de données. c'est-à-dire COLLATE Latin1_General_CI_AI

parce que notre application doit fonctionner à travers plusieurs RDBMSs, nous stockons notre définition de schéma dans le contrôle de version en utilisant la base de données neutre Torque format (XML). Nous contrôlons également les données de référence de notre base de données en format XML comme suit (où "Relationship" est l'un des tableaux de référence):

  <Relationship RelationshipID="1" InternalName="Manager"/>
  <Relationship RelationshipID="2" InternalName="Delegate"/>
  etc.

nous utilisons ensuite des outils maison pour générer les scripts de mise à niveau du schéma et des données de référence qui sont nécessaires pour passer de version X de la base de données à la version X + 1.

Nous ne stockons pas le schéma de base de données, nous stockons les changements à la base de données. Ce que nous faisons est de stocker les modifications du schéma de sorte que nous construisions un script de changement pour n'importe quelle version de la base de données et l'appliquions aux bases de données de nos clients. J'ai écrit une application utilitaire de base de données qui est distribuée avec notre application principale qui peut lire ce script et savoir quelles mises à jour doivent être appliquées. Il dispose également de suffisamment d'intelligence pour rafraîchir les vues et les procédures stockées selon les besoins.

nous avons eu le besoin de modifier notre base de données SQL après avoir migré vers une plate-forme x64 et notre ancienne version a rompu avec la migration. Nous avons écrit une application C# qui utilisait SQLDMO pour cartographier tous les objets SQL vers un dossier:

                Root
                    ServerName
                       DatabaseName
                          Schema Objects
                             Database Triggers*
                                .ddltrigger.sql
                             Functions
                                ..function.sql
                             Security
                                Roles
                                   Application Roles
                                      .approle.sql
                                   Database Roles
                                      .role.sql
                                Schemas*
                                   .schema.sql
                                Users
                                   .user.sql
                             Storage
                                Full Text Catalogs*
                                   .fulltext.sql
                             Stored Procedures
                                ..proc.sql
                             Synonyms*
                                .synonym.sql
                             Tables
                                ..table.sql
                                Constraints
                                   ...chkconst.sql
                                   ...defconst.sql
                                Indexes
                                   ...index.sql
                                Keys
                                   ...fkey.sql
                                   ...pkey.sql
                                   ...ukey.sql
                                Triggers
                                   ...trigger.sql
                             Types
                                User-defined Data Types
                                   ..uddt.sql
                                XML Schema Collections*
                                   ..xmlschema.sql
                             Views
                                ..view.sql
                                Indexes
                                   ...index.sql
                                Triggers
                                   ...trigger.sql

l'application comparerait alors la version nouvellement écrite à la version stockée dans SVN et s'il y avait des différences, elle mettrait à jour SVN. Nous avons déterminé que le fait d'exécuter le processus une fois par nuit était suffisant puisque nous ne faire autant de changements à SQL. Il nous permet de suivre les changements à tous les objets auxquels nous tenons plus il nous permet de reconstruire notre schéma complet en cas de problème grave.

j'ai écrit cette application il y a un moment, http://sqlschemasourcectrl.codeplex.com / qui numérisera vos PB SQL MSFT aussi souvent que vous le souhaitez et videra automatiquement vos objets (tables, vues, procs, fonctions, Paramètres sql) dans SVN. Fonctionne comme un charme. Je l'utilise avec Unfuddle (qui me permet d'obtenir des alertes sur checkins)

la solution typique est de vider la base de données si nécessaire et sauvegarder ces fichiers.

selon votre plate-forme de développement, il peut y avoir des plugins opensource disponibles. Rouler votre propre code pour le faire est généralement assez trivial.

Note: Vous pouvez vouloir sauvegarder le dump de base de données au lieu de le mettre dans le contrôle de version. Les fichiers peuvent devenir énormes rapidement dans le contrôle de version, et provoquer votre système de contrôle source entier à devenir lent (je suis rappel d'une histoire d'horreur du CVS en ce moment).

nous venons de commencer à utiliser le serveur de la fondation de L'équipe. Si votre base de données est de taille moyenne, alors visual studio a quelques intégrations de projet agréable avec construit dans comparer, comparer des données, des outils de remaniement de base de données, cadre de test de base de données, et même des outils de génération de données.

mais, ce modèle ne s'adapte pas très bien aux bases de données de très grande taille ou de tiers (qui chiffrent les objets). Donc, ce que nous avons fait est de ne stocker que nos objets personnalisés. Visual Studio / Team foundation le serveur fonctionne très bien pour cela.

TSF de la Base de données chef de la voûte. blog

MS TFS site

je suis D'accord avec la réponse D'ESV et pour cette raison précise j'ai commencé un petit projet il y a quelques temps pour aider à maintenir les mises à jour de la base de données dans un fichier très simple qui pourrait alors être maintenu un code source long side out. Il permet des mises à jour faciles pour les développeurs ainsi que L'UAT et la Production. L'outil fonctionne sur mais Sql Server et MySql.

quelques caractéristiques du projet:

• permits schema changes
• permet la population de l'arbre de valeur
• permet des inserts de données d'essai séparés pour par exemple. UAT
• permet l'option pour le retour (non automatisé)
• maintient la prise en charge de SQL server et Mysql
• a la capacité d'importer votre base de données existante dans le contrôle de version avec une commande simple(serveur sql seulement ... toujours en train de travailler sur mysql)

le code est hébergé sur google code. S'il vous plaît consulter Google code pour un peu plus information

http://code.google.com/p/databaseversioncontrol /

il y a peu de temps, j'ai trouvé un module VB bas qui utilisait des objets DMO et VSS pour obtenir un db entier scripté off et dans VSS. Je l'ai transformé en Script VB et l'ai posté ici . Vous pouvez facilement prendre les appels VSS et utiliser le truc DMO pour générer tous les scripts, puis appeler SVN à partir du même fichier batch qui appelle le VBScript pour les vérifier?

Dave J

j'utilise aussi une version dans la base de données stockée via la famille élargie de propriétés de la base de données des procédures. Mon application a des scripts pour chaque étape de la version (c.-à-d. passer de 1,1 à 1,2). Lorsqu'il est déployé, il ressemble à la version actuelle, puis exécute les scripts un par un jusqu'à ce qu'il atteigne la dernière version de l'application. Il n'y a pas de script qui a la version 'finale' droite, même déployé sur une DB propre fait le déploiement via une série d'étapes de mise à niveau.

maintenant ce que j'aime à ajouter, c'est que j'ai vu il y a deux jours une présentation sur le MS campus sur les nouvelles et à venir VS DB édition. La présentation a été axée spécifiquement sur ce sujet et j'ai été soufflé hors de l'eau. Vous devriez certainement vérifier cela, les nouvelles installations sont axées sur la conservation de la définition de schéma dans les scripts T-SQL (CREATEs), un moteur d'exécution delta pour comparer le schéma de déploiement avec le schéma défini et faire les modifications de delta et l'intégration avec l'intégration de code source, jusqu'à et y compris MSBUILD intégration continue pour les chutes de construction automatisées. La baisse contiendra un nouveau type de fichier, le .les fichiers dbschema, qui peuvent être amenés sur le site de déploiement et un outil en ligne de commande peut faire les 'deltas' réels et exécuter le déploiement. J'ai une entrée de blog sur ce sujet avec des liens vers les téléchargements VSDE, vous devriez les vérifier: http://rusanu.com/2009/05/15/version-control-and-your-database /

C'est une très vieille question, cependant beaucoup essaient de résoudre cela même maintenant. Tout ce qu'ils ont à faire est de faire des recherches sur les projets de bases de données Visual Studio. Sans cela, tout développement de base de données semble très faible. De l'organisation du code au déploiement en passant par le versioning, cela simplifie tout.

d'après mon expérience, la solution est double:

1. vous devez gérer les modifications apportées à la base de données de développement par plusieurs développeurs pendant le développement.

2. vous devez gérer les mises à jour de base de données dans les sites clients.

afin de gérer #1, vous aurez besoin d'un outil fort diff/merge de base de données. Le meilleur outil doit être capable d'effectuer fusionner automatiquement autant que possible tout en vous permettant de résoudre les conflits non résolus manuellement.

l'outil parfait devrait gérer les opérations de fusion en utilisant un algorithme de fusion à trois voies qui tient compte des changements apportés à la base de données de leur et à la base de données de MINE, par rapport à la base de données de BASE.

j'ai écrit un outil commercial qui fournit la prise en charge manuelle de la fusion pour les bases de données SQLite et je suis en train d'ajouter la prise en charge de la fusion à 3 voies algorithme pour SQLite. Regardez au http://www.sqlitecompare.com

afin de gérer le #2, vous aurez besoin d'un cadre de mise à niveau en place.

l'idée de base est de développer un cadre de mise à niveau automatique qui sait comment passer d'un schéma SQL existant au nouveau schéma SQL et peut construire un chemin de mise à niveau pour chaque installation DB existante.

Voir mon article sur le sujet dans http://www.codeproject.com/KB/database/sqlite_upgrade.aspx pour avoir une idée générale de ce dont je parle.

Bonne Chance

Liron Levi

découvrez DBGhost http://www.innovartis.co.uk/ . J'ai utilisé de façon automatisée depuis 2 ans maintenant et il fonctionne très bien. Il permet à nos constructions de DB de se produire un peu comme une construction Java ou C se produit, sauf pour la base de données. Vous savez ce que je veux dire.

je suggère d'utiliser des outils de comparaison pour improviser un système de contrôle de version pour votre base de données. Une bonne alternative sont xSQL Schema Comparer et xSQL données comparer .

maintenant, si votre but est d'avoir seulement le schéma de la base de données sous le contrôle de version, vous pouvez simplement utiliser le schéma xSQL Comparer pour générer des instantanés xSQL du schéma et ajouter ces fichiers dans votre contrôle de version. Que, pour revenir ou mettre à jour à un version il suffit de comparer la version actuelle de la base de données avec le snapshot de la version de destination.

hélas, si vous voulez avoir les données sous le contrôle de version aussi bien, vous pouvez utiliser xSQL Data Compare pour générer des scripts de changement pour votre base de données et ajouter le .fichiers sql dans votre contrôle de version. Vous pouvez ensuite exécuter ces scripts pour revenir / mettre à jour vers n'importe quelle version que vous voulez. Gardez à l'esprit que pour la fonctionnalité' revert ' vous devez générer des scripts de modification que lorsque exécuté rendra la Version 3 la même que la Version 2 et pour la fonctionnalité 'update', vous devez générer des scripts de changement qui font le contraire.

enfin, avec quelques compétences de base en programmation par lots, vous pouvez automatiser l'ensemble du processus en utilisant les versions en ligne de commande de xSQL Schema Compare et xSQL Data Compare

avertissement: je suis affilié à xSQL.