Ich möchte meine Datenbanken unter Versionskontrolle bringen. Hat jemand Ratschläge oder empfohlene Artikel, um mir den Einstieg zu erleichtern?

Ich möchte immer mindestens einige Daten darin haben (wie albern erwähnt: Benutzertypen und Administratoren). Ich möchte auch oft eine große Sammlung generierter Testdaten für Leistungsmessungen.

Martin Fowler hat meinen Lieblingsartikel zu diesem Thema geschrieben: http://martinfowler.com/articles/evodb.html . Ich entscheide mich dafür, Schema-Dumps nicht wie von alumb und anderen vorgeschlagen unter Versionskontrolle zu stellen , weil ich eine einfache Möglichkeit zum Aktualisieren meiner Produktionsdatenbank haben möchte.

Für eine Webanwendung, in der ich eine einzelne Produktionsdatenbankinstanz habe, verwende ich zwei Techniken:

Datenbank-Upgrade-Skripte

Ein Skript zum Aktualisieren der Sequenzdatenbank, das die DDL enthält, die zum Verschieben des Schemas von Version N auf N + 1 erforderlich ist. (Diese gehen in Ihr Versionskontrollsystem.) Eine _version_history_-Tabelle, so etwas wie

create table VersionHistory (
    Version int primary key,
    UpgradeStart datetime not null,
    UpgradeEnd datetime
    );

erhält jedes Mal einen neuen Eintrag, wenn ein Upgrade-Skript ausgeführt wird, das der neuen Version entspricht.

Dadurch wird sichergestellt, dass leicht erkennbar ist, welche Version des Datenbankschemas vorhanden ist, und dass Datenbankaktualisierungsskripts nur einmal ausgeführt werden. Auch dies sind keine Datenbank-Dumps. Vielmehr repräsentiert jedes Skript die Änderungen, die erforderlich sind, um von einer Version zur nächsten zu wechseln. Sie sind das Skript, das Sie auf Ihre Produktionsdatenbank anwenden, um sie zu "aktualisieren".

Entwickler-Sandbox-Synchronisation

1. Ein Skript zum Sichern, Bereinigen und Verkleinern einer Produktionsdatenbank. Führen Sie dies nach jedem Upgrade auf die Produktionsdatenbank aus.
2. Ein Skript zum Wiederherstellen (und gegebenenfalls Optimieren) der Sicherung auf der Workstation eines Entwicklers. Jeder Entwickler führt dieses Skript nach jedem Upgrade auf die Produktionsdatenbank aus.

Eine Einschränkung: Meine automatisierten Tests werden mit einer schemakorrekten, aber leeren Datenbank ausgeführt, sodass dieser Rat Ihren Anforderungen nicht perfekt entspricht.

Mit dem SQL Compare-Produkt von Red Gate können Sie nicht nur Vergleiche auf Objektebene durchführen und daraus Änderungsskripte generieren, sondern auch Ihre Datenbankobjekte mit einer [Objektnamen] .sql-Erstellung in eine nach Objekttyp geordnete Ordnerhierarchie exportieren Skript pro Objekt in diesen Verzeichnissen. Die Objekttyphierarchie sieht folgendermaßen aus:

\ Funktionen
\ Sicherheit
\ Sicherheit \ Rollen
\ Sicherheit \ Schemas
\ Sicherheit \ Benutzer
\ Gespeicherte Prozeduren
\ Tabellen

Wenn Sie Ihre Skripte nach Änderungen im selben Stammverzeichnis speichern, können Sie damit Ihr SVN-Repo aktualisieren und einen laufenden Verlauf jedes Objekts einzeln führen.

Dies ist eines der "schwierigen Probleme" bei der Entwicklung. Soweit ich weiß, gibt es keine perfekten Lösungen.

Wenn Sie nur die Datenbankstruktur und nicht die Daten speichern müssen, können Sie die Datenbank als SQL-Abfragen exportieren. (In Enterprise Manager: Klicken Sie mit der rechten Maustaste auf Datenbank -> SQL-Skript generieren. Ich empfehle, auf der Registerkarte "Optionen" die Option "Eine Datei pro Objekt erstellen" festzulegen.) Sie können diese Textdateien dann an svn übergeben und die Diff- und Protokollierungsfunktionen von svn verwenden.

Ich habe dies mit einem Batch-Skript verknüpft, das einige Parameter verwendet und die Datenbank einrichtet. Ich habe auch einige zusätzliche Abfragen hinzugefügt, die Standarddaten wie Benutzertypen und den Administrator eingeben. (Wenn Sie weitere Informationen dazu wünschen, posten Sie etwas und ich kann das Skript an einem zugänglichen Ort ablegen.)

Wenn Sie auch alle Daten aufbewahren müssen, empfehle ich, die Datenbank zu sichern und Redgate- Produkte ( http://www.red-gate.com/ ) zu verwenden, um die Vergleiche durchzuführen . Sie sind nicht billig, aber sie sind jeden Cent wert.

Zunächst müssen Sie das für Sie geeignete Versionskontrollsystem auswählen:

• Zentrales Versionskontrollsystem - Ein Standardsystem, bei dem Benutzer vor / nach der Bearbeitung von Dateien auschecken / einchecken und die Dateien auf einem einzigen zentralen Server gespeichert werden

• Verteiltes Versionskontrollsystem - Ein System, in dem das Repository geklont wird und jeder Klon tatsächlich die vollständige Sicherung des Repositorys darstellt. Wenn also ein Server abstürzt, kann jedes geklonte Repository verwendet werden, um es wiederherzustellen. Nachdem Sie das richtige System für Ihre Anforderungen ausgewählt haben Sie müssen das Repository einrichten, das den Kern jedes Versionskontrollsystems bildet. All dies wird im folgenden Artikel erläutert: http://solutioncenter.apexsql.com/sql-server-source-control-part-i-understanding -Quellensteuerungsgrundlagen /

Nach dem Einrichten eines Repositorys und bei einem zentralen Versionskontrollsystem eines Arbeitsordners können Sie diesen Artikel lesen . Es zeigt, wie Sie die Quellcodeverwaltung in einer Entwicklungsumgebung einrichten, indem Sie:

• SQL Server Management Studio über den MSSCCI-Anbieter,

• Visual Studio- und SQL Server-Datentools

• Ein Drittanbieter-Tool ApexSQL Source Control

Hier bei Red Gate bieten wir ein Tool an, SQL Source Control , das mithilfe der SQL Compare-Technologie Ihre Datenbank mit einem TFS- oder SVN-Repository verknüpft. Dieses Tool lässt sich in SSMS integrieren und ermöglicht es Ihnen, wie gewohnt zu arbeiten, außer dass Sie jetzt die Objekte festschreiben können.

Für einen migrationsbasierten Ansatz (besser geeignet für automatisierte Bereitstellungen) bieten wir SQL Change Automation an (früher ReadyRoll genannt) an, mit dem eine Reihe inkrementeller Skripts als Visual Studio-Projekt erstellt und verwaltet werden.

In der SQL-Quellcodeverwaltung können statische Datentabellen angegeben werden. Diese werden in der Quellcodeverwaltung als INSERT-Anweisungen gespeichert.

Wenn Sie über Testdaten sprechen, empfehlen wir Ihnen, Testdaten entweder mit einem Tool oder über ein von Ihnen definiertes Skript nach der Bereitstellung zu generieren oder einfach eine Produktionssicherung in der Entwicklungsumgebung wiederherzustellen.

Vielleicht möchten Sie sich Liquibase ( http://www.liquibase.org/ ) ansehen . Selbst wenn Sie das Tool selbst nicht verwenden, werden die Konzepte des Datenbankänderungsmanagements oder des Refactorings recht gut behandelt.

+1 für alle, die die RedGate-Tools empfohlen haben, mit einer zusätzlichen Empfehlung und einer Einschränkung.

SqlCompare verfügt auch über eine anständig dokumentierte API: So können Sie beispielsweise eine Konsolen-App schreiben, die Ihren quellengesteuerten Skriptordner beim Einchecken mit einer CI-Integrationstestdatenbank synchronisiert, damit jemand eine Änderung des Schemas aus seinem Skriptordner eincheckt Es wird automatisch zusammen mit der entsprechenden Änderung des Anwendungscodes bereitgestellt. Dies hilft, die Lücke zu Entwicklern zu schließen, die vergessen, Änderungen in ihrer lokalen Datenbank bis zu einer gemeinsam genutzten Entwicklungsdatenbank weiterzugeben (ungefähr die Hälfte von uns, glaube ich :)).

Eine Einschränkung ist, dass mit einer Skriptlösung oder auf andere Weise die RedGate-Tools so flüssig sind, dass die der Abstraktion zugrunde liegenden SQL-Realitäten leicht vergessen werden. Wenn Sie alle Spalten in einer Tabelle umbenennen, kann SqlCompare die alten Spalten nicht den neuen Spalten zuordnen und löscht alle Daten in der Tabelle. Es werden Warnungen generiert, aber ich habe gesehen, wie Leute daran vorbei geklickt haben. Ich denke, es gibt einen allgemeinen Punkt, den Sie erwähnen sollten: Sie können die DB-Versionierung und das Upgrade bisher nur automatisieren - die Abstraktionen sind sehr undicht.

Wir verwenden DBGhost , um unsere SQL-Datenbank zu verwalten. Anschließend fügen Sie Ihre Skripte zum Erstellen einer neuen Datenbank in Ihre Versionskontrolle ein. Sie erstellen entweder eine neue Datenbank oder aktualisieren eine vorhandene Datenbank auf das Schema in der Versionskontrolle. Auf diese Weise müssen Sie sich keine Gedanken über das Erstellen von Änderungsskripten machen (obwohl Sie dies immer noch tun können, wenn Sie beispielsweise den Datentyp einer Spalte ändern möchten und Daten konvertieren müssen).

Verwenden Sie in VS 2010 das Datenbankprojekt.

1. Schreiben Sie Ihre Datenbank aus
2. Nehmen Sie Änderungen an Skripten oder direkt auf Ihrem Datenbankserver vor
3. Synchronisieren Sie mit Daten> Schema vergleichen

Macht eine perfekte DB-Versionierungslösung und macht das Synchronisieren von DBs zum Kinderspiel.

Es ist ein guter Ansatz, Datenbankskripte mit Änderungsskripten in der Versionskontrolle zu speichern, damit Sie eine beliebige Datenbank aktualisieren können. Möglicherweise möchten Sie auch Schemas für verschiedene Versionen speichern, damit Sie eine vollständige Datenbank erstellen können, ohne alle Änderungsskripte anwenden zu müssen. Die Handhabung der Skripte sollte automatisiert sein, damit Sie keine manuelle Arbeit leisten müssen.

Ich denke, es ist wichtig, für jeden Entwickler eine separate Datenbank zu haben und keine gemeinsam genutzte Datenbank zu verwenden. Auf diese Weise können die Entwickler unabhängig von anderen Entwicklern Testfälle und Entwicklungsphasen erstellen.

Das Automatisierungstool sollte über Mittel zum Behandeln von Datenbankmetadaten verfügen, die angeben, welche Datenbanken sich in welchem ​​Entwicklungsstand befinden und welche Tabellen versionierbare Daten usw. enthalten.

Sie können sich auch eine Migrationslösung ansehen. Mit diesen können Sie Ihr Datenbankschema in C # -Code angeben und Ihre Datenbankversion mit MSBuild auf und ab rollen.

Ich verwende derzeit DbUp und es hat gut funktioniert.

Sie haben keine Einzelheiten zu Ihrer Zielumgebung oder zu Einschränkungen erwähnt, daher ist dies möglicherweise nicht vollständig anwendbar. Wenn Sie jedoch nach einer Möglichkeit suchen, ein sich entwickelndes DB-Schema effektiv zu verfolgen, und die Idee der Verwendung nicht beeinträchtigen Ruby, die Migrationen von ActiveRecord sind genau das Richtige für Sie.

Migrationen definieren programmgesteuert Datenbanktransformationen mithilfe von Ruby DSL. Jede Transformation kann angewendet oder (normalerweise) rückgängig gemacht werden, sodass Sie zu einem bestimmten Zeitpunkt zu einer anderen Version Ihres DB-Schemas springen können. Die Datei, die diese Transformationen definiert, kann wie jeder andere Quellcode in die Versionskontrolle eingecheckt werden.

Da Migrationen Teil von ActiveRecord sind , werden sie normalerweise in Full-Stack-Rails-Apps verwendet. Sie können ActiveRecord jedoch mit minimalem Aufwand unabhängig von Rails verwenden. Weitere Informationen zur Verwendung von AR-Migrationen außerhalb von Rails finden Sie hier.

Jede Datenbank sollte unter Quellcodekontrolle stehen. Was fehlt, ist ein Tool zum automatischen Skript aller Datenbankobjekte - und "Konfigurationsdaten" - in eine Datei, die dann zu jedem Versionsverwaltungssystem hinzugefügt werden kann. Wenn Sie SQL Server verwenden, ist meine Lösung hier: http://dbsourcetools.codeplex.com/ . Habe Spaß. - Nathan.

Es ist einfach.

1. Wenn das Basisprojekt fertig ist, müssen Sie ein vollständiges Datenbankskript erstellen. Dieses Skript wird an SVN übergeben. Es ist die erste Version.

2. Danach erstellen alle Entwickler Änderungsskripte (ALTER ..., neue Tabellen, Sprocs usw.).

3. Wenn Sie die aktuelle Version benötigen, sollten Sie alle neuen Änderungsskripte ausführen.

4. Wenn die App für die Produktion freigegeben wird, kehren Sie zu 1 zurück (aber dann wird es natürlich eine sukzessive Version sein).

Nant hilft Ihnen bei der Ausführung dieser Änderungsskripte. :) :)

Und merke dir. Alles funktioniert gut, wenn es Disziplin gibt. Jedes Mal, wenn eine Datenbankänderung festgeschrieben wird, werden auch entsprechende Funktionen im Code festgeschrieben.

Wenn Sie eine kleine Datenbank haben und die gesamte Version versionieren möchten, kann dieses Batch-Skript hilfreich sein. Es löst, komprimiert und checkt eine MSSQL-Datenbank-MDF-Datei in Subversion ein.

Wenn Sie Ihr Schema hauptsächlich versionieren möchten und nur eine kleine Menge von Referenzdaten haben, können Sie möglicherweise SubSonic Migrations verwenden , um dies zu handhaben. Der Vorteil besteht darin, dass Sie problemlos nach oben oder unten auf eine bestimmte Version migrieren können.

Um den Speicherauszug für ein Quellcodeverwaltungssystem etwas schneller zu gestalten, können Sie anhand der Versionsinformationen in sysobjects sehen, welche Objekte sich seit dem letzten Mal geändert haben.

Setup: Erstellen Sie in jeder Datenbank, die Sie inkrementell überprüfen möchten, eine Tabelle, um die Versionsinformationen aus der letzten Überprüfung zu speichern (beim ersten Durchlauf leer). Löschen Sie diese Tabelle, wenn Sie Ihre gesamte Datenstruktur erneut scannen möchten.

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)
)

Normaler Ausführungsmodus: Sie können die Ergebnisse aus diesem SQL-Code übernehmen, SQL-Skripte nur für diejenigen erstellen, an denen Sie interessiert sind, und sie in ein Quellcodeverwaltungselement Ihrer Wahl einfügen.

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

Hinweis: Wenn Sie in einer Ihrer Datenbanken eine nicht standardmäßige Sortierung verwenden, müssen Sie diese durch /* COLLATE */Ihre Datenbanksortierung ersetzen . dhCOLLATE Latin1_General_CI_AI

Da unsere App über mehrere RDBMS hinweg funktionieren muss, speichern wir unsere Schemadefinition in der Versionskontrolle im datenbankneutralen Drehmomentformat (XML). Wir haben auch die Versionskontrolle der Referenzdaten für unsere Datenbank im XML-Format wie folgt (wobei "Beziehung" eine der Referenztabellen ist):

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

Anschließend verwenden wir selbst entwickelte Tools, um die Skripts für Schemaaktualisierung und Referenzdatenaktualisierung zu generieren, die erforderlich sind, um von Version X der Datenbank auf Version X + 1 zu wechseln.

Wir speichern das Datenbankschema nicht, wir speichern die Änderungen an der Datenbank. Wir speichern die Schemaänderungen so, dass wir ein Änderungsskript für jede Version der Datenbank erstellen und es auf die Datenbanken unserer Kunden anwenden. Ich habe eine Datenbankdienstprogramm-App geschrieben, die mit unserer Hauptanwendung verteilt wird, die dieses Skript lesen und wissen kann, welche Updates angewendet werden müssen. Es verfügt auch über genügend Smarts, um Ansichten und gespeicherte Prozeduren nach Bedarf zu aktualisieren.

Nach der Migration auf eine x64-Plattform mussten wir unsere SQL-Datenbank versionieren, und unsere alte Version brach mit der Migration ab. Wir haben eine C # -Anwendung geschrieben, die SQLDMO verwendet, um alle SQL-Objekte einem Ordner zuzuordnen:

                Wurzel
                    Servername
                       Name der Datenbank
                          Schemaobjekte
                             Datenbank-Trigger *
                                .ddltrigger.sql
                             Funktionen
                                ..function.sql
                             Sicherheit
                                Rollen
                                   Anwendungsrollen
                                      .approle.sql
                                   Datenbankrollen
                                      .role.sql
                                Schemata *
                                   .schema.sql
                                Benutzer
                                   .user.sql
                             Lager
                                Volltextkataloge *
                                   .fulltext.sql
                             Gespeicherte Prozeduren
                                ..proc.sql
                             Synonyme *
                                .synonym.sql
                             Tabellen
                                ..table.sql
                                Einschränkungen
                                   ... chkconst.sql
                                   ... defconst.sql
                                Indizes
                                   ... index.sql
                                Schlüssel
                                   ... fkey.sql
                                   ... pkey.sql
                                   ... ukey.sql
                                Löst aus
                                   ... trigger.sql
                             Typen
                                Benutzerdefinierte Datentypen
                                   ..uddt.sql
                                XML-Schemasammlungen *
                                   ..xmlschema.sql
                             Ansichten
                                ..view.sql
                                Indizes
                                   ... index.sql
                                Löst aus
                                   ... trigger.sql

Die Anwendung vergleicht dann die neu geschriebene Version mit der in SVN gespeicherten Version und aktualisiert SVN, wenn es Unterschiede gibt. Wir haben festgestellt, dass es ausreichend ist, den Prozess einmal pro Nacht auszuführen, da wir nicht so viele Änderungen an SQL vornehmen. Es ermöglicht uns, Änderungen an allen Objekten zu verfolgen, die uns wichtig sind, und es ermöglicht uns, unser vollständiges Schema im Falle eines schwerwiegenden Problems neu zu erstellen.

Ich habe diese App vor einiger Zeit geschrieben: http://sqlschemasourcectrl.codeplex.com/. Sie scannt Ihre MSFT SQL-Datenbanken so oft Sie möchten und speichert Ihre Objekte (Tabellen, Ansichten, Prozesse, Funktionen, SQL-Einstellungen) automatisch in SVN. Klappt wunderbar. Ich benutze es mit Unfuddle (wodurch ich Benachrichtigungen über Checkins erhalten kann)

Die typische Lösung besteht darin, die Datenbank nach Bedarf zu sichern und diese Dateien zu sichern.

Abhängig von Ihrer Entwicklungsplattform sind möglicherweise OpenSource-Plugins verfügbar. Das Rollen Ihres eigenen Codes ist normalerweise ziemlich trivial.

Hinweis: Möglicherweise möchten Sie den Datenbankspeicherauszug sichern, anstatt ihn in die Versionskontrolle zu übernehmen. Die Dateien können bei der Versionskontrolle sehr schnell werden und dazu führen, dass Ihr gesamtes Versionskontrollsystem langsam wird (ich erinnere mich gerade an eine CVS-Horrorgeschichte).

Wir haben gerade angefangen, Team Foundation Server zu verwenden. Wenn Ihre Datenbank mittelgroß ist, verfügt Visual Studio über einige nette Projektintegrationen mit integrierten Tools zum Vergleichen, Vergleichen von Daten, zum Refactoring von Datenbanken, zum Framework für Datenbanktests und sogar zu Tools zur Datengenerierung.

Dieses Modell passt jedoch nicht sehr gut zu Datenbanken von Drittanbietern (die Objekte verschlüsseln). Wir haben also nur unsere benutzerdefinierten Objekte gespeichert. Der Visual Studio / Team Foundation Server funktioniert dafür sehr gut.

TFS Database Chief Arch. Blog

MS TFS-Site

Ich bin mit der Antwort von ESV einverstanden und habe aus diesem Grund vor einiger Zeit ein kleines Projekt gestartet, um Datenbankaktualisierungen in einer sehr einfachen Datei zu verwalten, die dann als Long-Side-Out-Quellcode verwaltet werden kann. Es ermöglicht einfache Updates für Entwickler sowie UAT und Produktion. Das Tool funktioniert nur mit SQL Server und MySQL.

Einige Projektfunktionen:

• Ermöglicht Schemaänderungen
• Ermöglicht Wertbaumpopulation
• Ermöglicht separate Testdateneinfügungen für z. UAT
• Ermöglicht Option für Rollback (nicht automatisiert)
• Behält die Unterstützung für SQL Server und MySQL bei
• Hat die Möglichkeit, Ihre vorhandene Datenbank mit einem einfachen Befehl in die Versionskontrolle zu importieren (nur SQL Server ... funktioniert immer noch mit MySQL)

Der Code wird auf Google Code gehostet. Weitere Informationen finden Sie im Google-Code

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

Vor einiger Zeit habe ich ein VB-Basismodul gefunden, das DMO- und VSS-Objekte verwendet, um eine gesamte Datenbank aus und in VSS zu schreiben. Ich habe daraus ein VB-Skript gemacht und es hier gepostet . Sie könnten die VSS-Aufrufe einfach herausnehmen und das DMO-Material verwenden, um alle Skripte zu generieren, und dann SVN aus derselben Batch-Datei aufrufen, die das VBScript aufruft, um sie einzuchecken?

Dave J.

Ich verwende auch eine Version in der Datenbank, die über die Prozedurfamilie der erweiterten Eigenschaften der Datenbank gespeichert ist. Meine Anwendung verfügt über Skripte für jeden Versionsschritt (dh von 1.1 auf 1.2). Bei der Bereitstellung wird die aktuelle Version angezeigt und die Skripts werden einzeln ausgeführt, bis die letzte App-Version erreicht ist. Es gibt kein Skript mit der direkten "endgültigen" Version. Selbst die Bereitstellung auf einer sauberen Datenbank erfolgt über eine Reihe von Upgrade-Schritten.

Was ich jetzt hinzufügen möchte, ist, dass ich vor zwei Tagen auf dem MS-Campus eine Präsentation über die neue und kommende VS DB-Edition gesehen habe. Die Präsentation war speziell auf dieses Thema ausgerichtet und ich wurde aus dem Wasser geblasen. Sie sollten es auf jeden Fall ausprobieren. Die neuen Funktionen konzentrieren sich darauf, die Schemadefinition in T-SQL-Skripten (CREATEs), einer Laufzeit-Delta-Engine zum Vergleichen des Bereitstellungsschemas mit dem definierten Schema, beizubehalten und die Delta-ALTERs und die Integration mit der Quellcode-Integration bis zu durchzuführen und einschließlich der kontinuierlichen Integration von MSBUILD für automatisierte Build-Drops. Die Ablage enthält einen neuen Dateityp, die .dbschema-Dateien, die zum Bereitstellungsstandort gebracht werden können, und ein Befehlszeilentool kann die eigentlichen "Deltas" ausführen und die Bereitstellung ausführen. Ich habe einen Blogeintrag zu diesem Thema mit Links zu den VSDE-Downloads. Sie sollten sie sich ansehen:http://rusanu.com/2009/05/15/version-control-and-your-database/

Es ist eine sehr alte Frage, aber viele versuchen dies schon jetzt zu lösen. Sie müssen lediglich nach Visual Studio-Datenbankprojekten suchen. Ohne dies sieht jede Datenbankentwicklung sehr schwach aus. Von der Code-Organisation über die Bereitstellung bis zur Versionierung wird alles vereinfacht.

Nach meiner Erfahrung gibt es zwei Lösungen:

1. Sie müssen Änderungen an der Entwicklungsdatenbank vornehmen, die von mehreren Entwicklern während der Entwicklung vorgenommen werden.

2. Sie müssen Datenbank-Upgrades an Kundenstandorten durchführen.

Um mit # 1 fertig zu werden, benötigen Sie ein starkes Datenbank-Diff / Merge-Tool. Das beste Tool sollte in der Lage sein, so viel wie möglich automatisch zusammenzuführen und gleichzeitig nicht behandelte Konflikte manuell zu lösen.

Das perfekte Tool sollte Zusammenführungsvorgänge mithilfe eines 3-Wege-Zusammenführungsalgorithmus verarbeiten, der die Änderungen berücksichtigt, die in der THEIRS-Datenbank und der MINE-Datenbank relativ zur BASE-Datenbank vorgenommen wurden.

Ich habe ein kommerzielles Tool geschrieben, das manuelle Zusammenführungsunterstützung für SQLite-Datenbanken bietet, und ich füge derzeit Unterstützung für den 3-Wege-Zusammenführungsalgorithmus für SQLite hinzu. Überprüfen Sie es auf http://www.sqlitecompare.com

Um mit # 2 fertig zu werden, benötigen Sie ein Upgrade-Framework.

Die Grundidee besteht darin, ein automatisches Upgrade-Framework zu entwickeln, das weiß, wie ein Upgrade von einem vorhandenen SQL-Schema auf das neuere SQL-Schema durchgeführt wird, und einen Upgrade-Pfad für jede vorhandene DB-Installation erstellen kann.

Lesen Sie meinen Artikel zu diesem Thema unter http://www.codeproject.com/KB/database/sqlite_upgrade.aspx , um eine allgemeine Vorstellung davon zu bekommen, wovon ich spreche.

Viel Glück

Liron Levi

Schauen Sie sich DBGhost http://www.innovartis.co.uk/ an . Ich benutze es seit 2 Jahren automatisiert und es funktioniert großartig. Es ermöglicht unseren DB-Builds, ähnlich wie ein Java- oder C-Build, mit Ausnahme der Datenbank. Du weißt was ich meine.

Ich würde vorschlagen, Vergleichstools zu verwenden, um ein Versionskontrollsystem für Ihre Datenbank zu improvisieren. Eine gute Alternative sind xSQL Schema Compare und xSQL Data Compare .

Wenn Sie nun nur das Schema der Datenbank unter Versionskontrolle haben möchten, können Sie einfach xSQL Schema Compare verwenden, um xSQL-Snapshots des Schemas zu generieren und diese Dateien in Ihre Versionskontrolle aufzunehmen. Um eine bestimmte Version wiederherzustellen oder zu aktualisieren, vergleichen Sie einfach die aktuelle Version der Datenbank mit dem Snapshot für die Zielversion.

Wenn Sie die Daten auch unter Versionskontrolle haben möchten, können Sie mit xSQL Data Compare Änderungsskripte für Ihre Datenbank generieren und die SQL-Dateien zu Ihrer Versionskontrolle hinzufügen. Sie können diese Skripte dann ausführen, um sie auf eine beliebige Version zurückzusetzen / zu aktualisieren. Beachten Sie, dass Sie für die Funktion "Zurücksetzen" Änderungsskripte generieren müssen, bei deren Ausführung Version 3 mit Version 2 identisch ist. Für die Funktion "Aktualisieren" müssen Sie Änderungsskripte generieren, die das Gegenteil bewirken.

Schließlich können Sie mit einigen grundlegenden Batch-Programmierkenntnissen den gesamten Prozess mithilfe der Befehlszeilenversionen von xSQL Schema Compare und xSQL Data Compare automatisieren

Haftungsausschluss: Ich bin mit xSQL verbunden.