Exemplarische Vorgehensweise: Vergleichen der Schemas einer Datenbank und eines Datenbankprojekts

Dieses Thema gilt für folgende Anwendungsbereiche:

Visual Studio Ultimate	Visual Studio Premium	Visual Studio Professional	Visual Studio Express

In dieser exemplarischen Vorgehensweise vergleichen Sie mithilfe von Visual Studio das Schema eines Datenbankprojekts mit dem Schema einer Datenbank. Abhängig davon, wie das Team das Datenbankprojekt und die Datenbank verwendet, haben Sie dann die Möglichkeit, Schemaänderungen in die eine oder die andere Richtung zu kopieren. Während des Lebenszyklus der Datenbankentwicklung durch das Team können die folgenden typischen Szenarios eintreten:

Das Projekt ist die Quelle und die Datenbank das Ziel. Mit einem Datenbankprojekt können Sie eine Datenbank entwickeln oder verwalten. Nachdem Sie die Änderungen am Projektschema vorgenommen haben, kopieren Sie diese in die Datenbank, die auf einem Stagingserver gehostet wird. Im Anschluss kann die Datenbank vom Team auf einem Produktionsserver bereitgestellt werden.

Durch den Vergleich in dieser exemplarischen Vorgehensweise wird anhand der Schemaunterschiede ein Datendefinitionssprache-Skript (Data Definition Language, DDL) generiert. Mit diesem Skript können Sie das Datenbankprojekt anschließend teilweise oder vollständig auf die Datenbank anwenden. Weitere Informationen finden Sie unter Weitergeben von Änderungen vom Projekt an die Datenbank.
Die Datenbank ist die Quelle und das Projekt das Ziel. Möglicherweise wird im Schema einer Produktionsdatenbank ein Fehler gefunden, oder das Schema ist nicht mehr aktuell und muss erneuert werden. Bei einem solchen Fund muss das Team die Datenbank möglicherweise dringend aktualisieren. Um das Projekt mit der Datenbank synchron zu halten, können Sie die Aktualisierung dann in ein Datenbankprojekt importieren. Weitere Informationen erhalten Sie unter Gewusst wie: Importieren von Aktualisierungen aus einer Datenbank in das Datenbankprojekt.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben veranschaulicht:

Setupphase

Erstellen Sie ein Datenbankprojekt. Zu Beginn weist das neue Projekt noch keinen Inhalt auf.
Importieren Sie ein Datenbankschema aus einem Skript.
Konfigurieren und erstellen Sie das Datenbankprojekt auf dem Datenbankserver, und stellen Sie dieses bereit. Die Datenbank und das Projekt weisen identische Schemas auf.

Produktionsphase

Fügen Sie der Datenbank eine Tabelle hinzu. Sie fügen die dreispaltige Tabelle InternationalShippers hinzu.
Vergleichen Sie die beiden Schemas. In diesem Vergleich legen Sie das Datenbankprojekt als Quelle und die Datenbank als Ziel fest. Daher wird die Tabelle InternationalShippers in den Ergebnissen als neue Tabelle im Datenbankprojekt angezeigt.
Geben Sie die Änderungen vom Projekt an die Datenbank weiter. Sie können nun die neue Version der Tabelle InternationalShippers aus dem Datenbankprojekt an die bereitgestellte Datenbank weitergeben. Wenn Sie diese Prozedur befolgen, werden Teile der Beispieldatenbank überschrieben.

Tipp

Sie können auch Änderungen aus einer Quelldatenbank an ein Datenbankprojekt weitergeben. Weitere Informationen erhalten Sie unter Gewusst wie: Importieren von Aktualisierungen aus einer Datenbank in das Datenbankprojekt.

Vorbereitungsmaßnahmen

Zum Ausführen dieser exemplarischen Vorgehensweise benötigen Sie die folgenden Anwendungen und Berechtigungen:

SQL Server 2008
Berechtigungen zum Erstellen und Aktualisieren von Datenbanken auf dem Zieldatenbankserver
Visual Studio Premium oder Visual Studio Ultimate

Setupphase

Erstellen Sie ein Datenbankprojekt.

So erstellen Sie ein Datenbankprojekt

Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

Das Dialogfeld Neues Projekt wird angezeigt.
Erweitern Sie unter Installierte Vorlagen den Knoten Datenbank, und klicken Sie dann auf SQL Server.
Klicken Sie in der Liste der Vorlagen auf SQL Server 2008-Datenbankprojekt.
Geben Sie unter Name CompareProject ein, und klicken Sie dann auf OK.

Das leere Projekt CompareProject wird geöffnet und im Projektmappen-Explorer angezeigt.

Importieren eines Datenbankschemas aus einem Skript

So erstellen Sie ein Skript, aus dem Sie ein Schema importieren können

Zeigen Sie im Menü Datei auf Neu, und klicken Sie auf Datei.

Das Dialogfeld Neue Datei wird angezeigt.
Klicken Sie in der Liste Kategorien auf Allgemein, wenn dieser Eintrag nicht bereits hervorgehoben ist.
Klicken Sie in der Liste Vorlagen auf SQL-Datei und dann auf Öffnen.

Der Transact-SQL-Editor wird geöffnet.

Kopieren Sie den folgenden Code, und fügen Sie diesen im Transact-SQL-Editor ein.

PRINT N'Creating Sales...';
GO
CREATE SCHEMA [Sales]
    AUTHORIZATION [dbo];
GO
PRINT N'Creating Sales.Customer...';
GO
CREATE TABLE [Sales].[Customer] (
    [CustomerID]   INT IDENTITY (1, 1) NOT NULL,
    [CustomerName] NVARCHAR (40) NOT NULL,
    [YTDOrders] INT NOT NULL,
    [YTDSales] INT NOT NULL
);
GO
PRINT N'Creating Sales.Orders...';
GO
CREATE TABLE [Sales].[Orders] (
    [CustomerID] INT NOT NULL,
    [OrderID] INT IDENTITY (1, 1) NOT NULL,
    [OrderDate] DATETIME NOT NULL,
    [FilledDate] DATETIME NULL,
    [Status] CHAR (1) NOT NULL,
    [Amount] INT NOT NULL
);
GO
PRINT N'Creating Sales.Def_Customer_YTDOrders...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDOrders] DEFAULT 0 FOR [YTDOrders];
GO
PRINT N'Creating Sales.Def_Customer_YTDSales...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDSales] DEFAULT 0 FOR [YTDSales];
GO
PRINT N'Creating Sales.Def_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_OrderDate] DEFAULT GetDate() FOR [OrderDate];
GO
PRINT N'Creating Sales.Def_Orders_Status...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_Status] DEFAULT 'O' FOR [Status];
GO
PRINT N'Creating Sales.PK_Customer_CustID...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [PK_Customer_CustID] PRIMARY KEY CLUSTERED ([CustomerID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.PK_Orders_OrderID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [PK_Orders_OrderID] PRIMARY KEY CLUSTERED ([OrderID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.FK_Orders_Customer_CustID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [FK_Orders_Customer_CustID] FOREIGN KEY ([CustomerID]) REFERENCES [Sales].[Customer] ([CustomerID]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating Sales.CK_Orders_FilledDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_FilledDate] CHECK ((FilledDate >= OrderDate) AND (FilledDate < '01/01/2010'));
GO
PRINT N'Creating Sales.CK_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_OrderDate] CHECK ((OrderDate > '01/01/2005') and (OrderDate < '01/01/2020'));
GO
PRINT N'Creating Sales.uspCancelOrder...';
GO
CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'X'
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspFillOrder...';
GO
CREATE PROCEDURE [Sales].[uspFillOrder]
@OrderID INT, @FilledDate DATETIME
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'F',
       [FilledDate] = @FilledDate
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspNewCustomer...';
GO
CREATE PROCEDURE [Sales].[uspNewCustomer]
@CustomerName NVARCHAR (40)
AS
BEGIN
INSERT INTO [Sales].[Customer] (CustomerName) VALUES (@CustomerName);
SELECT SCOPE_IDENTITY()
END
GO
PRINT N'Creating Sales.uspPlaceNewOrder...';
GO
CREATE PROCEDURE [Sales].[uspPlaceNewOrder]
@CustomerID INT, @Amount INT, @OrderDate DATETIME, @Status CHAR (1)='O'
AS
BEGIN
DECLARE @RC INT
BEGIN TRANSACTION
INSERT INTO [Sales].[Orders] (CustomerID, OrderDate, FilledDate, Status, Amount) 
     VALUES (@CustomerID, @OrderDate, NULL, @Status, @Amount)
SELECT @RC = SCOPE_IDENTITY();
UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders + @Amount
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
RETURN @RC
END
GO

Klicken Sie im Menü Datei auf SqlQuery_1.sql speichern unter.

Das Dialogfeld Datei speichern unter wird geöffnet.
Geben Sie in Objektname den Dateinamen SampleImportScript.sql ein.

Sie können die Datei an einem beliebigen Speicherort auf dem Computer speichern. Notieren Sie sich den Speicherort, da Sie diesen in der nächsten Prozedur verwenden müssen.
Klicken Sie auf Speichern.
Klicken Sie im Menü Datei auf Projektmappe schließen.

Danach erstellen Sie ein Datenbankprojekt und importieren das Schema aus dem erstellten Skript.

So importieren Sie ein Datenbankschema aus einem Skript

Klicken Sie im Menü Projekt auf Datenbankschema importieren.
Wenn Sie die Willkommensseite gelesen haben, klicken Sie auf Weiter.
Klicken Sie auf Durchsuchen, und wechseln Sie zu dem Speicherort, an dem Sie die Datei SampleImportScript.sql gespeichert haben.
Doppelklicken Sie auf die Datei SampleImportScript.sql, und klicken Sie dann auf Fertig stellen.

Das Skript wird importiert, und die in diesem Skript definierten Objekte werden dem Datenbankprojekt hinzugefügt.
Überprüfen Sie die Zusammenfassungsergebnisse, und klicken Sie dann auf Fertig stellen.

Konfigurieren, Erstellen und Bereitstellen des Datenbankprojekts

Mit diesen Prozeduren wird eine Datenbank erstellt, deren importiertes Schema in einer isolierten Entwicklungsumgebung (oder einer Sandbox) gespeichert ist, in der Sie die Datenbank testen und entwickeln können.

So konfigurieren und erstellen Sie das Datenbankprojekt

Klicken Sie im Projektmappen-Explorer auf das Projekt CompareProject.
Klicken Sie im Menü Projekt auf CompareProject-Eigenschaften.

Die Eigenschaften für das Projekt CompareProject werden angezeigt.
Klicken Sie auf die Registerkarte Bereitstellen.
Klicken Sie in der Liste Bereitstellungsvorgang auf Bereitstellungsskript erstellen und in Datenbank bereitstellen (.sql).
Klicken Sie unter Einstellungen für die Zieldatenbank auf Bearbeiten.
Geben Sie im Dialogfeld Verbindungseigenschaften die Verbindungseigenschaften für die Datenbank ein, in der Sie arbeiten möchten, und klicken Sie dann auf OK.

Im Feld Zielverbindung wird die richtige Verbindungszeichenfolge angezeigt.

Warnung

Sie sollten die neue Datenbank auf einem Testserver, einem Entwicklungsserver oder auf dem lokalen Computer erstellen. Ein Produktionsserver sollte nicht verwendet werden.
Geben Sie im Textfeld Zieldatenbankname den Namen CompareProjectDB ein.
Klicken Sie im Menü Datei auf Alle speichern.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

Das Bereitstellungsskript wird auf Grundlage der von Ihnen festgelegten Projekteigenschaften erstellt. Der Status des Builds wird im Fenster Ausgabe angezeigt, und die letzte Zeile lautet Build: 1 erfolgreich oder aktuell.

So stellen Sie das Datenbankprojekt bereit

Klicken Sie im Projektmappen-Explorer auf das Projekt CompareProject.
Klicken Sie im Menü Erstellen auf CompareProject bereitstellen.

Sie können auch im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt klicken und anschließend auf Bereitstellen klicken.

Warnung

Sie sollten diese Bereitstellung auf einem Testserver, einem Entwicklungsserver oder dem lokalen Computer ausführen. Der Produktionsserver sollte nicht verwendet werden.

Das Datenbankprojekt wird in einer neuen Datenbank bereitgestellt. Der Status der Bereitstellung wird im Ausgabefenster angezeigt, wobei die letzte Zeile Die Bereitstellung war erfolgreich lautet.

Produktionsphase

Hinzufügen einer Tabelle zum Datenbankprojekt

So fügen Sie dem Projekt eine Tabelle hinzu

Klicken Sie im Menü Ansicht auf Schemaansicht der Datenbank.

Die Schemaansicht wird geöffnet, und das Schema des Projekts CompareProject wird angezeigt.
Erweitern Sie in der Schemaansicht den Knoten CompareProject und den Knoten Schemas.
Klicken Sie mit der rechten Maustaste auf Sales, zeigen Sie auf Hinzufügen, und klicken Sie auf Tabelle.

Das Dialogfeld Neues Element hinzufügen - CompareProject wird geöffnet.
Klicken Sie unter Vorlagen auf Tabelle.
Geben Sie im Feld Name den Namen InternationalShippers ein, und klicken Sie dann auf Hinzufügen.

Die Tabelle InternationalShippers wird dem Projekt CompareProject hinzugefügt. Die Tabellendefinition wird im Transact-SQL-Editor angezeigt.

Ändern Sie das SQL-Skript in InternationalShippers.table.sql in die folgenden Anweisungen:

CREATE TABLE [Sales].[InternationalShippers]
(
[ShipperID] [int] NOT NULL IDENTITY(1,1),
[CompanyName] [nvarchar] (40) NOT NULL,
[Region] [nvarchar] (40) NOT NULL,
[Phone] [nvarchar] (24) NULL
) ON [PRIMARY]

Klicken Sie auf InternationalShippers.table.sql speichern.
Klicken Sie in der Schemaansicht mit der rechten Maustaste auf die Tabelle InternationalShippers, und klicken Sie anschließend auf Datei im Projektmappen-Explorer anzeigen.

Die Datei InternationalShippers.sql wird im Projektmappen-Explorer hervorgehoben.
Drücken Sie F4.

Das Eigenschaftenfenster mit den Eigenschaften der Datei InternationalShippers.table.sql wird angezeigt. Die Build Action-Eigenschaft wird auf Build festlegen, um anzugeben, dass die Datei die Definition für ein Datenbankobjekt enthält und analysiert und validiert werden soll.

Vergleichen der beiden Schemas

So vergleichen Sie die beiden Schemas

Zeigen Sie im Menü Daten auf Schemavergleich, und klicken Sie auf Neuer Schemavergleich.
Das Dialogfeld Neuer Schemavergleich wird angezeigt.
Klicken Sie unter Zielschema auf Datenbank, und geben Sie eine Verbindung mit der Datenbank an, die Sie zuvor in dieser exemplarischen Vorgehensweise bereitgestellt haben, und klicken Sie auf OK.

Das Schema der Datenbank wird mit dem Schema des geänderten Projekts verglichen, und die Ergebnisse werden im Fenster Schemavergleich angezeigt. In der Spalte CompareProject wird die Tabelle [Sales].[InternationalShippers] angezeigt. Der Status der Tabelle ist Neu und die Aktualisierungsaktion Erstellen. Wenn Sie zu diesem Zeitpunkt Änderungen weitergäben, würde die Tabelle in der Zieldatenbank erstellt. Weitere Informationen erhalten Sie im folgenden Verfahren:

So überprüfen und ignorieren Sie erwartete Unterschiede

Führen Sie in der Liste der Vergleichsergebnisse einen Bildlauf zum Knoten SQL-Dateien durch.

Für die Zieldatenbank werden zwei Zeilen mit dem Status Fehlt angezeigt: eine Zeile für die Dateigruppendatei und eine Zeile für die Protokolldatei.
Klicken Sie für jede Zeile in die Spalte Aktion aktualisieren, um die Aktion in Überspringen zu ändern.

Wenn Sie ein Datenbankschema aktualisieren, soll die Dateigruppendatei oder die Protokolldatei für die Zieldatenbank in der Regel nicht geändert werden. Für die Zieldatenbank werden weiterhin die aktuellen Dateien verwendet, da die Aktion in Überspringen geändert wurde.

Danach können Sie optional die Zieldatenbank aktualisieren, sodass diese mit der Quelldatenbank übereinstimmt.

Weitergeben von Änderungen vom Projekt an die Datenbank

So geben Sie Änderungen an die Zieldatenbank weiter

Klicken Sie im Fenster Schemavergleich auf Updates schreiben.

Tipp

Wenn das Projekt einen oder mehrere Fehler enthält, kann die Schaltfläche Updates schreiben deaktiviert werden. In diesem Fall wird auf der Statusleiste Schemavergleich eine Meldung angezeigt.

Die im Fenster Schemavergleich aufgeführten Aktionen, u. a. die Aktion Erstellen für die Tabelle InternationalShippers, werden ausgeführt. Durch diese Synchronisierung wird das Schema der Datenbank so geändert, dass es dem Schema des Datenbankprojekts entspricht. Wenn der Aktualisierungsvorgang abgeschlossen wurde, werden die Schemas erneut verglichen, und die Ergebnisse werden aktualisiert.

Während das Zielschema aktualisiert wird, können Sie den Vorgang abbrechen, indem Sie das Menü Daten öffnen, auf Schemavergleich zeigen und dann auf Schreiben auf Ziel beenden klicken.

Warnung

Da einige Schemaänderungen im Bereich einer Transaktion nicht ausgeführt werden können, können Datenverluste auftreten, wenn Sie einen Aktualisierungsvorgang abbrechen. Als Vorbereitung für das erneute Erstellen könnte beispielsweise eine Tabelle in der Zieldatenbank gelöscht worden sein. Wenn Sie die Aktualisierung in diesem Moment abbrechen, kann die Tabelle verloren gehen. Wenn diese Art von Datenverlust auftritt, sollten Sie die Schemas erneut vergleichen.

Siehe auch

Aufgaben

Gewusst wie: Vergleichen von Datenbankschemas

Gewusst wie: Vergleichen und Synchronisieren der Daten von zwei Datenbanken

Konzepte

Vergleichen und Synchronisieren von Datenbankschemas

Vergleichen und Synchronisieren von Daten in einer oder mehreren Tabellen mit Daten aus einer Referenzdatenbank

Last updated on 2011-07-20