Wie führt man Versionskontrolle für eine SQL Server-Datenbank durch?

Question

Ich möchte meine Datenbanken unter Versionskontrolle halten.

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

Wie kann ich Versionskontrolle auf meine Datenbank anwenden?

Answer 1

Weil unsere App mit verschiedenen RDBMSs funktionieren muss, speichern wir unsere Schema-Definition im Versionskontrollsystem im datenbankneutralen Torque-Format (XML). Wir versionieren auch die Referenzdaten für unsere Datenbank im XML-Format wie folgt (wobei "Beziehung" eine der Referenztabelle ist):

  usw.

Dann verwenden wir selbst entwickelte Tools, um die Schema-Upgrade- und Referenzdaten-Upgrade-Skripte zu generieren, die erforderlich sind, um von Version X der Datenbank auf Version X + 1 zu wechseln.

Answer 2

Ich habe diese App vor einiger Zeit geschrieben, http://sqlschemasourcectrl.codeplex.com/, die Ihre MSFT SQL-Datenbanken so oft wie gewünscht scannen und automatisch Ihre Objekte (Tabellen, Ansichten, Prozeduren, Funktionen, SQL-Einstellungen) in SVN ablegen wird. Funktioniert wie ein Zauber. Ich benutze es mit Unfuddle (was mir ermöglicht, Benachrichtigungen über Check-Ins zu erhalten)

Answer 3

Um den Dump in ein Quellcode-Verwaltungssystem zu beschleunigen, können Sie sehen, welche Objekte sich seit dem letzten Mal geändert haben, indem Sie die Versionsinformationen in sysobjects verwenden.

Setup: Erstellen Sie eine Tabelle in jeder Datenbank, die Sie inkrementell überprüfen möchten, um die Versionsinformationen vom letzten Mal 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 Betriebsmodus: Sie können die Ergebnisse dieses SQL-Statements nehmen, SQL-Skripte nur für die Objekte erstellen, die Sie interessieren, und sie in einem Quellcode-Verwaltungssystem Ihrer Wahl ablegen.

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

-- Fügen Sie die Werte vom Ende des letzten Durchlaufs in #tmp ein
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

-- Dieser nächste Abschnitt listet alle Unterschiede in den Skripten auf.
SET NOCOUNT OFF

--Umbenannt.
SELECT 'umbenannt' 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 

--Geändert (mit ALTER)
SELECT 'geändert' AS ChangeType, o.name /*COLLATE*/, 
       'geändert' 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

--Geändert (tatsächlich gelöscht und neu erstellt [aber nicht umbenannt])
SELECT 'geändert' AS ChangeType, t.name, 'gelöscht' 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

--Gelöscht
SELECT 'gelöscht' 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

--Hinzugefügt
SELECT 'hinzugefügt' 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 eine nicht standardmäßige Kollation in einer Ihrer Datenbanken verwenden, müssen Sie /* COLLATE */ durch Ihre Datenbankkollation ersetzen. z.B. COLLATE Latin1_General_CI_AI

Answer 4

Wir speichern das Datenbankschema nicht, wir speichern die Änderungen an der Datenbank. Was wir tun, ist, die Schemaänderungen zu speichern, damit wir ein Änderungsskript für jede Version der Datenbank erstellen und es auf die Datenbanken unserer Kunden anwenden können. Ich habe eine Datenbank-Hilfs-App geschrieben, die mit unserer Hauptanwendung verteilt wird und dieses Skript lesen kann und weiß, welche Updates angewendet werden müssen. Es hat auch genug Intelligenz, um Ansichten und gespeicherte Prozeduren bei Bedarf zu aktualisieren.

Answer 5

Wir mussten unsere SQL-Datenbank versionieren, nachdem wir auf eine x64-Plattform migriert waren und unsere alte Version bei der Migration kaputt gegangen ist. Wir haben eine C#-Anwendung geschrieben, die SQLDMO verwendet hat, um alle SQL-Objekte in einen Ordner zu mappen:

                Root
                    ServerName
                       DatenbankName
                          Schema-Objekte
                             Datenbankauslöser
                                .ddltrigger.sql
                             Funktionen
                                ..function.sql
                             Sicherheit
                                Rollen
                                   Anwendungsrollen
                                      .approle.sql
                                   Datenbankrollen
                                      .role.sql
                                Schemata
                                   .schema.sql
                                Benutzer
                                   .user.sql
                             Speicherung
                                Volltext-Kataloge
                                   .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
                                Trigger
                                   ...trigger.sql
                             Typen
                                Benutzerdefinierte Datentypen
                                   ..uddt.sql
                                XML-Schema-Sammlungen
                                   ..xmlschema.sql
                             Ansichten
                                ..view.sql
                                Indizes
                                   ...index.sql
                                Trigger
                                   ...trigger.sql

Die Anwendung verglich dann die neu geschriebene Version mit der in SVN gespeicherten Version und aktualisierte SVN, wenn es Unterschiede gab. Wir haben festgestellt, dass es ausreichte, den Prozess einmal pro Nacht laufen zu lassen, da wir nicht viele Änderungen an SQL vornehmen. Es ermöglicht uns, Änderungen an allen Objekten, die uns wichtig sind, zu verfolgen, und es ermöglicht uns, unser gesamtes Schema im Falle eines schwerwiegenden Problems neu aufzubauen.