Database
 sql >> Datenbank >  >> RDS >> Database

Erstellen und Bereitstellen mehrerer Datenbankversionen über Schema-Snapshots

Übersicht

Dieser Artikel behandelt die Verwendung von Datenbankschema-Snapshots, um verschiedene Versionen einer Datenbank zu verwalten, die in verschiedenen Umgebungen bereitgestellt werden sollen.

Datenbankschema-Snapshots sind Point-in-Time-Kopien des aktuellen Zustands der Datenbank, die normalerweise verwendet werden, um die Unterschiede auszugleichen, wenn Änderungen von einer Umgebung in eine andere Umgebung implementiert werden.

Dieser Artikel konzentriert sich auf ein bestimmtes Szenario, in dem Datenbankschema-Snapshots mehr als nur Point-in-Time-Kopien der Datenbank sind, sondern dazu verwendet werden, neue Versionen bestimmter Umgebungen zu erstellen.

Was ist ein Datenbankschema-Snapshot

Ein Datenbankschema-Snapshot ist einfach eine gespeicherte Point-in-Time-Kopie einer Datenbank.

Mit anderen Worten, ein Datenbankschema-Snapshot ist eine exakte Kopie der Datenbankstruktur, die keine Daten in ihrer ursprünglichen Form enthält.

Datenbankschema bezieht sich auf alle Datenbankobjekte, einschließlich Tabellen, Ansichten und gespeicherter Prozeduren. Wir erstellen einen Snapshot des Datenbankschemas, um die Objektdefinitionen für die spätere Verwendung einzufrieren.

Warum wird ein Datenbankschema-Snapshot benötigt?

Datenbankschema-Snapshots können für folgende Zwecke verwendet werden:

  1. Kopieren eines vorhandenen Zustands einer Datenbank für zukünftige Bezugnahme oder zukünftige Verwendung.
  2. Versionierung einer Datenbank durch mehrere Datenbankschema-Snapshots.
  3. Erstellen einer Point-in-Time-Kopie der Datenbankstruktur für eine schnelle Wiederherstellung.
  4. Erstellen einer Kopie des Zieldatenbankschemas vor dem Bereitstellen neuer Änderungen.
  5. Erstellen einer aktuellsten stabilen Kopie des Datenbankschemas, bevor mit weiteren Änderungen fortgefahren wird.
  6. Erstellen und Freigeben von Datenbankänderungen an ein externes Teammitglied, das nicht direkt auf die Datenbankumgebung zugreifen kann.
  7. Der Datenbankschema-Snapshot kann auch verwendet werden, um die Unterschiede zwischen der aktuellen Arbeit und der in der Vergangenheit geleisteten Arbeit zu vergleichen.
  8. Datenbankschema-Snapshots können auch für die getrennte Veröffentlichung verwendet werden.

Anforderung, mehrere Datenbankversionen aufzubewahren

Wenn Ihr Datenbankentwicklungsteam eine besondere Anforderung erhalten hat, mehrere Datenbankversionen zu behalten und zu pflegen, die in mehreren Umgebungen bereitgestellt werden sollen dann besteht eine der Lösungen darin, Datenbankschema-Snapshots zu verwenden, um die Anforderung zu erfüllen.

Mehrere Datenbankversionen erstellen

Wie bereits erwähnt, werden Datenbankschema-Snapshots nicht nur als Point-in-Time-Kopien der Datenbankstruktur verwendet, sondern können auch verwendet werden, um mehrere Datenbankversionen gleichzeitig zu erstellen und bereitzustellen.

Beispieldatenbankeinrichtung (Technische Schulung)

Öffnen Sie dbForge Studio für SQL Server oder SSMS (SQL Server Management Studio), um eine Beispieldatenbank namens TechnicalTraining einzurichten die die Informationen über technische Kurse, Studenten und Trainer mit den wenigen Tabellen wie folgt enthält:

-- (1) Creating TechnicalTraining sample database 
CREATE DATABASE TechnicalTraining;
GO

USE TechnicalTraining

-- (2) Creating Student table
CREATE TABLE Student (
  StudentId INT IDENTITY
 ,Name VARCHAR(50) NOT NULL
 ,RegistrationDate DATETIME2 NULL
 ,Notes VARCHAR(200) NULL
 ,CONSTRAINT PK_Student_StudentId PRIMARY KEY CLUSTERED (StudentId)
)
GO

-- (3) Creating Trainer table
CREATE TABLE Trainer (
  TrainerId INT IDENTITY
 ,Name VARCHAR(50) NOT NULL
 ,Qualification VARCHAR(50) NOT NULL
 ,Notes VARCHAR(200) NULL
 ,CONSTRAINT PK_Trainer_TrainerId PRIMARY KEY CLUSTERED (TrainerId)
)
GO

-- (4) Creating Course table
CREATE TABLE Course (
  CourseId INT IDENTITY
 ,Name VARCHAR(50) NOT NULL
 ,TrainerId INT NULL
 ,Detail VARCHAR(200) NULL
 ,CONSTRAINT PK_Course_CourseId PRIMARY KEY CLUSTERED (CourseId)
) ON [PRIMARY]
GO

ALTER TABLE Course
ADD CONSTRAINT FK_Course_TrainerId FOREIGN KEY (TrainerId) REFERENCES dbo.Trainer (TrainerId)
GO


-- (5) Creating StudentCourse table 
CREATE TABLE [dbo].[StudentCourse] (
    [StudentCourseId] INT  IDENTITY(1,1) NOT NULL,
    [StudentId]       INT            NULL,
    [CourseId]        INT            NULL,
    [PercentScore]    DECIMAL (5, 2) NULL,
    CONSTRAINT [PK_StudentCourse_StudentCourseId] PRIMARY KEY CLUSTERED ([StudentCourseId] ASC),
    CONSTRAINT [FK_StudentCourse_Student_StudentId] FOREIGN KEY ([StudentId]) REFERENCES [dbo].[Student] ([StudentId]),
    CONSTRAINT [FK_StudentCourse_Course_CourseId] FOREIGN KEY ([CourseId]) REFERENCES [dbo].[Course] ([CourseId])
);
GO

-- (6) Create view to see student progress report
CREATE VIEW StudentProgress as
SELECT s.Name AS StudentName,c.Name as CourseName,t.Name AS Trainer,sc.PercentScore FROM StudentCourse sc 
INNER JOIN Student s
on s.StudentId=sc.StudentId
INNER JOIN Course c
on c.CourseId=sc.CourseId
INNER JOIN Trainer t
on t.TrainerId=c.TrainerId
GO

Bitte beachten Sie, dass die TechnicalTraining-Datenbank so strukturiert ist, dass viele Studenten viele Kurse belegen können, während jeder Kurs nur einen Trainer haben kann, wie unten gezeigt:

Bitte beachten Sie, dass ich dbForge Studio für SQL Server verwende, sodass die Ausgabe möglicherweise anders aussieht, wenn Sie denselben Code in SSMS (SQL Server Management Studio) ausführen. Es gibt jedoch keinen Unterschied zwischen Skripten und ihren Ergebnissen.

Füllen Sie die Datenbank mit dem folgenden Skript:

USE TechnicalTraining

-- (1) Populating Trainer table
SET IDENTITY_INSERT [dbo].[Trainer] ON
INSERT INTO [dbo].[Trainer] ([TrainerId], [Name],  [Qualification], [Notes]) VALUES (1, N'George', N'MSc Computer Science', NULL)
INSERT INTO [dbo].[Trainer] ([TrainerId], [Name],  [Qualification], [Notes]) VALUES (2, N'Akeel', N'MSc Database Management', NULL)
INSERT INTO [dbo].[Trainer] ([TrainerId], [Name],  [Qualification], [Notes]) VALUES (3, N'Sarah', N'MSc Data Science', NULL)
INSERT INTO [dbo].[Trainer] ([TrainerId], [Name],  [Qualification], [Notes]) VALUES (4, N'Ben', N'BSc Computer Science', NULL)
SET IDENTITY_INSERT [dbo].[Trainer] OFF


-- (2) Populating Course table
SET IDENTITY_INSERT [dbo].[Course] ON
INSERT INTO [dbo].[Course] ([CourseId], [Name], [TrainerId], [Detail]) VALUES (1, N'Database Development', 1, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [Name], [TrainerId], [Detail]) VALUES (2, N'Data Analysis ', 2, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [Name], [TrainerId], [Detail]) VALUES (3, N'Data Reports Development', 2, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [Name], [TrainerId], [Detail]) VALUES (4, N'Basics of Business Intelligence', 3, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [Name], [TrainerId], [Detail]) VALUES (5, N'Big Data Fundamentals', 4, NULL)
SET IDENTITY_INSERT [dbo].[Course] OFF


-- (3) Populating Student table
SET IDENTITY_INSERT [dbo].[Student] ON
INSERT INTO [dbo].[Student] ([StudentId], [Name],  [RegistrationDate], [Notes]) VALUES (1, N'Asif', N'2017-01-01 00:00:00', NULL)
INSERT INTO [dbo].[Student] ([StudentId], [Name],  [RegistrationDate], [Notes]) VALUES (2, N'Mike', N'2017-02-01 00:00:00', NULL)
INSERT INTO [dbo].[Student] ([StudentId], [Name],  [RegistrationDate], [Notes]) VALUES (3, N'Naveed', N'2017-03-10 00:00:00', NULL)
INSERT INTO [dbo].[Student] ([StudentId], [Name],  [RegistrationDate], [Notes]) VALUES (4, N'Sam', N'2017-04-15 00:00:00', NULL)
INSERT INTO [dbo].[Student] ([StudentId], [Name],  [RegistrationDate], [Notes]) VALUES (5, N'Mona', N'2017-07-10 00:00:00', NULL)
SET IDENTITY_INSERT [dbo].[Student] OFF

-- (4) Populating StudentCourse table
SET IDENTITY_INSERT [dbo].[StudentCourse] ON
INSERT INTO [dbo].[StudentCourse] ([StudentCourseId], [StudentId], [CourseId], [PercentScore]) VALUES (1, 1, 1, CAST(72.00 AS Decimal(5, 2)))
INSERT INTO [dbo].[StudentCourse] ([StudentCourseId], [StudentId], [CourseId], [PercentScore]) VALUES (2, 1, 2, CAST(75.00 AS Decimal(5, 2)))
INSERT INTO [dbo].[StudentCourse] ([StudentCourseId], [StudentId], [CourseId], [PercentScore]) VALUES (3, 2, 2, CAST(80.00 AS Decimal(5, 2)))
INSERT INTO [dbo].[StudentCourse] ([StudentCourseId], [StudentId], [CourseId], [PercentScore]) VALUES (4, 2, 3, CAST(70.00 AS Decimal(5, 2)))
INSERT INTO [dbo].[StudentCourse] ([StudentCourseId], [StudentId], [CourseId], [PercentScore]) VALUES (5, 3, 5, CAST(80.00 AS Decimal(5, 2)))
SET IDENTITY_INSERT [dbo].[StudentCourse] OFF

Datenbankprüfung

Klicken Sie mit der rechten Maustaste auf StudentFortschritt unter Ansichten Ordner und klicken Sie auf Daten abrufen oder geben Sie alternativ den folgenden T-SQL-Code ein:

-- View students progress
SELECT s.Name,c.Name as CourseName,t.Name,sc.PercentScore FROM StudentCourse sc
INNER JOIN Student s
on s.StudentId=sc.StudentId
INNER JOIN Course c
on c.CourseId=sc.CourseId
INNER JOIN Trainer t
on t.TrainerId=c.TrainerId
order by s.Name

Die Ausgabe sieht wie folgt aus:

Setup-Version 1 durch Erstellen eines Datenbankschema-Snapshots

Dies ist der Zeitpunkt, um die Point-in-Time-Kopie des Datenbankschemas zu speichern, da die aktuelle Datenbankstruktur die Anforderungen für Version 1 der Datenbank erfüllt.

Schema-Snapshot Version 1 erstellen

Klicken Sie mit der rechten Maustaste auf TechnicalTraining Datenbank im Datenbank-Explorer von dbForge Studio for SQL Server (oder Sie können ein ähnliches Tool Ihrer Wahl verwenden, das Datenbankschema-Snapshots erstellen kann), klicken Sie auf Aufgaben und klicken Sie dann auf Skriptordner oder Snapshot erstellen… wie unten gezeigt:

Erstellen Sie einen Schnappschuss am gewünschten Ort und nennen Sie ihn TechnicalTraining-Version-001-StudentCourseTrainer.snap wie folgt:

Überprüfen Sie Schema-Snapshot-Version 1

Überprüfen Sie den Ordner, um den kürzlich erstellten Snapshot des Datenbankschemas von Version 1 anzuzeigen:

Neuen Tabellenkurstyp hinzufügen

Lassen Sie uns nun eine weitere Tabelle namens CourseType hinzufügen in die vorhandene Datenbank mit Hilfe des folgenden Skripts:

-- Adding CourseType table 
CREATE TABLE CourseType (
  CourseTypeId INT IDENTITY
 ,Name VARCHAR(50) NOT NULL
 ,Detail VARCHAR(250) NULL
 ,CONSTRAINT PK_CourseType_CourseId PRIMARY KEY CLUSTERED (CourseTypeId)
);
GO

Fügen Sie die Daten wie folgt in die Tabelle ein:

SET IDENTITY_INSERT [dbo].[CourseType] ON
INSERT INTO [dbo].[CourseType] ([CourseTypeId], [Name], [Detail]) VALUES (1, N'Basic', NULL)
INSERT INTO [dbo].[CourseType] ([CourseTypeId], [Name], [Detail]) VALUES (2, N'Intermediate', NULL)
INSERT INTO [dbo].[CourseType] ([CourseTypeId], [Name], [Detail]) VALUES (3, N'Advanced', NULL)
SET IDENTITY_INSERT [dbo].[CourseType] OFF

Ändern Sie die Kurstabelle, um eine Kurstypspalte hinzuzufügen

Aktualisieren Sie die Course-Tabelle, um den CourseType-Fremdschlüssel hinzuzufügen:

-- Drop foreign key constraint
ALTER TABLE StudentCourse
Drop Constraint [FK_StudentCourse_Course_CourseId]

-- Drop Course table
DROP TABLE Course

-- Create Course table with new column CourseTypeId
CREATE TABLE [dbo].[Course] (
    [CourseId]  INT           IDENTITY (1, 1) NOT NULL,
    [CourseTypeId] INT,
	[Name]      VARCHAR (50)  NOT NULL,
    [TrainerId] INT           NULL,
    [Detail]    VARCHAR (200) NULL,
    CONSTRAINT [PK_Course_CourseId] PRIMARY KEY CLUSTERED ([CourseId] ASC),
    CONSTRAINT [FK_Course_TrainerId] FOREIGN KEY ([TrainerId]) REFERENCES [dbo].[Trainer] ([TrainerId]), 
    CONSTRAINT [FK_Course_CourseTypeId] FOREIGN KEY ([CourseTypeId]) REFERENCES [CourseType]([CourseTypeId])
);
GO

Fügen Sie der neu geänderten Course-Tabelle wie folgt Daten hinzu:

-- Add data to the Course table
SET IDENTITY_INSERT [dbo].[Course] ON
INSERT INTO [dbo].[Course] ([CourseId], [CourseTypeId], [Name], [TrainerId], [Detail]) VALUES (1, 1, N'Database Development', 1, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [CourseTypeId], [Name], [TrainerId], [Detail]) VALUES (2, 3, N'Data Analysis ', 2, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [CourseTypeId], [Name], [TrainerId], [Detail]) VALUES (3, 2, N'Data Reports Development', 2, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [CourseTypeId], [Name], [TrainerId], [Detail]) VALUES (4, 1, N'Basics of Business Intelligence', 3, NULL)
INSERT INTO [dbo].[Course] ([CourseId], [CourseTypeId], [Name], [TrainerId], [Detail]) VALUES (5, 1, N'Big Data Fundamentals', 4, NULL)
SET IDENTITY_INSERT [dbo].[Course] OFF

-- Add Foreign key constraint back to StudentCourse table
ALTER TABLE StudentCourse ADD CONSTRAINT [FK_StudentCourse_Course_CourseId] FOREIGN KEY ([CourseId]) REFERENCES [dbo].[Course] ([CourseId])

Neue Ansicht CoursesWithTypes hinzufügen

Fügen Sie nun eine neue Ansicht hinzu, um alle Kurse mit ihren Typen wie folgt anzuzeigen:

-- Creating a view to see courses with their types
Create VIEW CoursesWithTypes AS
SELECT c.CourseId,c.Name as CousreName,ct.Name as CourseType FROM dbo.Course c inner join dbo.CourseType ct
on c.CourseTypeId=ct.CourseTypeId;
GO

Datenbankprüfung

Zeigen Sie die Datenbankstruktur an, um die neuesten Änderungen anzuzeigen:

Führen Sie die Ansicht CoursesWithTypes:

aus

Setup-Version 2 durch Erstellen eines Datenbankschema-Snapshots

Erstellen Sie eine weitere Point-in-Time-Kopie der Datenbankstruktur, um Version 2 der Datenbank zu markieren.

Erstellen Sie einen Datenbankschema-Snapshot und nennen Sie ihn TechnicalTraining-Version-002-StudentCourseTrainerCourseType.snap wie folgt:

Bereitstellen mehrerer Datenbankversionen

Nach erfolgreicher Erstellung von Datenbankschema-Snapshots für Version 1 und Version 2 können wir jetzt je nach Anforderung jede Version in jeder Umgebung bereitstellen.

Entwicklungsdatenbank aus Schema-Snapshot Version 1 erstellen

Klicken Sie auf Vergleich -> Neuer Schemavergleich aus der Menüleiste in dbForge Studio für SQL Server:

Legen Sie als Nächstes den Quelltyp als Snapshot fest und suchen Sie den Datenbankschema-Snapshot Version 1 TechnicalTraining-Version-001-StudentCourseTrainer.snap wir zuvor erstellt haben, und klicken Sie auf das Plus-Symbol, um die Zieldatenbank spontan zu erstellen:

Geben Sie den Datenbanknamen TechnicalTrainingV1_DEV ein und klicken Sie auf OK:

Klicken Sie auf Weiter :

Klicken Sie auf Weiter erneut, um die standardmäßigen Optionen auszuwählen und klicken Sie dann auf Weiter um mit den Standardoptionen für die Schemazuordnung fortzufahren, und klicken Sie dann auf Vergleichen :

Synchronisieren Sie Quelle und Ziel, indem Sie wie unten gezeigt auf das grüne Symbol in der Mitte klicken:

Klicken Sie nach einigen weiteren Schritten auf Synchronisieren :

Führen Sie als Nächstes das Skript aus, um schließlich TechnicalTrainingV1_DEV zu erstellen Datenbank aus dem Datenbankschema-Snapshot, der Version 1 der Datenbank darstellt:

Zeigen Sie die neu erstellte Datenbank an, die eine Kopie der TechnicalTraining-Datenbankversion 1 ist:

Entwicklungsdatenbank aus Schema-Snapshot-Version 2 erstellen

Erstellen Sie jetzt Version 2 der Datenbank, indem Sie die genannten Schritte ausführen, um Version 1 zu erstellen, indem Sie einfach auf Version 2 Database Schema Snapshot TechnicalTraining-Version-002-StudentCourseTrainerCourseType zeigen diesmal:

Vergleich von Version 1 und Version 2

Lassen Sie uns schnell beide Datenbanken vergleichen, um die Unterschiede zu sehen.

Herzliche Glückwünsche! Sie haben erfolgreich mehrere Versionen der Datenbank durch Datenbankschema-Snapshots erstellt.

Dinge zu tun

Sie können jetzt ganz einfach Datenbankschema-Snapshots verwenden, um mehrere Versionen der Datenbank zu erstellen und bereitzustellen.

  1. Erstellen Sie mehrere Versionen von SQLDevBlogTDD, die in meinem vorherigen Artikel erwähnt wurden.
  2. Erstellen Sie mehrere Versionen der Datenbank, wobei Version 1 die Gesamtzahl der Artikel pro Autorenbericht erfüllt Anforderung und Version 2, die den Bericht zur Gesamtzahl der Artikel pro Jahr erfüllt nach meinem vorherigen Artikel.
  3. Lesen Sie meinen vorherigen Artikel Art of Isolating Dependencies and Data in Database Unit Testing durch und prüfen Sie, ob Sie zwei verschiedene Versionen der Datenbank durch Datenbankschema-Snapshots erstellen können, eine mit tSQLt-Unit-Tests und die andere ohne tSQLt-Unit-Tests.

Nützliches Tool:

dbForge Studio für SQL Server – leistungsstarke IDE für die Verwaltung, Verwaltung, Entwicklung, Datenberichterstattung und -analyse von SQL Server.