Database
 sql >> Base de données >  >> RDS >> Database

Création et déploiement de plusieurs versions de base de données via des instantanés de schéma

Aperçu

Cet article explique comment utiliser des instantanés de schéma de base de données pour gérer différentes versions d'une base de données à déployer dans différents environnements.

Les instantanés de schéma de base de données sont des copies ponctuelles de l'état actuel de la base de données qui sont normalement utilisées pour concilier les différences lors du déploiement des modifications d'un environnement à un autre.

Cet article se concentrera sur un scénario particulier où les instantanés de schéma de base de données sont plus que de simples copies ponctuelles de la base de données, ils sont plutôt utilisés pour créer de nouvelles versions d'environnements spécifiques.

Qu'est-ce qu'un instantané de schéma de base de données ?

Un instantané de schéma de base de données est simplement une copie enregistrée à un moment donné d'une base de données.

En d'autres termes, un instantané de schéma de base de données est une copie exacte de la structure de la base de données qui n'inclut pas les données dans leur forme d'origine.

Le schéma de base de données fait référence à tous les objets de la base de données, y compris les tables, les vues et les procédures stockées. Nous créons un instantané du schéma de base de données pour figer les définitions d'objets pour une utilisation ultérieure.

Pourquoi un instantané du schéma de base de données est-il nécessaire ?

Les instantanés de schéma de base de données peuvent être utilisés aux fins suivantes :

  1. Copier un état existant d'une base de données pour référence future ou utilisation future.
  2. Versionner une base de données via plusieurs instantanés de schéma de base de données.
  3. Création d'une copie ponctuelle de la structure de la base de données pour une restauration rapide
  4. Création d'une copie du schéma de base de données cible avant de déployer de nouvelles modifications.
  5. Créer une copie stable la plus récente du schéma de base de données avant de procéder à d'autres modifications.
  6. Création et partage des modifications de la base de données avec un membre de l'équipe externe qui ne peut pas accéder directement à l'environnement de la base de données
  7. L'instantané du schéma de base de données peut également être utilisé pour comparer les différences entre le travail en cours et le travail effectué dans le passé.
  8. Les instantanés de schéma de base de données peuvent également être utilisés pour la publication déconnectée.

Exigence de conserver plusieurs versions de base de données

Si votre équipe de développement de base de données a reçu une exigence spéciale pour conserver et maintenir plusieurs versions de base de données à déployer dans plusieurs environnements alors l'une des solutions consiste à utiliser des instantanés de schéma de base de données pour répondre à l'exigence.

Création de plusieurs versions de base de données

Comme indiqué précédemment, les instantanés de schéma de base de données ne sont pas seulement utilisés comme copies ponctuelles de la structure de la base de données, mais peuvent également être utilisés pour créer et déployer plusieurs versions de base de données en même temps.

Exemple de configuration de la base de données (formation technique)

Ouvrez dbForge Studio pour SQL Server ou SSMS (SQL Server Management Studio) pour configurer un exemple de base de données appelé TechnicalTraining qui contient les informations sur les cours techniques, les étudiants et les formateurs avec les quelques tableaux suivants :

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

Veuillez noter que la base de données TechnicalTraining est structurée de manière à ce que de nombreux étudiants puissent suivre plusieurs cours alors que chaque cours ne peut avoir qu'un seul formateur, comme indiqué ci-dessous :

Veuillez noter que j'utilise dbForge Studio pour SQL Server, donc l'aspect de la sortie peut différer si vous exécutez le même code dans SSMS (SQL Server Management Studio). Cependant, il n'y a aucune différence entre les scripts et leurs résultats.

Remplissez la base de données à l'aide du script suivant :

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

Vérification de la base de données

Faites un clic droit sur StudentProgress sous les Vues dossier et cliquez sur Récupérer les données ou saisissez le code T-SQL suivant :

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

Le résultat est le suivant :

Configurer la version 1 en créant un instantané du schéma de base de données

C'est le moment d'enregistrer la copie ponctuelle du schéma de la base de données puisque la structure actuelle de la base de données répond aux exigences de la version 1 de la base de données.

Créer un instantané de schéma version 1

Faites un clic droit sur TechnicalTraining base de données dans Database Explorer de dbForge Studio for SQL Server (ou vous pouvez utiliser n'importe quel outil similaire de votre choix capable de créer un instantané de schéma de base de données), cliquez sur Tâches puis cliquez sur Créer un dossier de scripts ou un instantané… comme indiqué ci-dessous :

Créez un instantané à l'emplacement de votre choix et nommez-le TechnicalTraining-Version-001-StudentCourseTrainer.snap comme suit :

Vérifiez la version 1 de l'instantané du schéma

Vérifiez le dossier pour afficher l'instantané du schéma de base de données récemment créé de la version 1 :

Ajouter un nouveau type de cours de tableau

Ajoutons maintenant une autre table appelée CourseType à la base de données existante à l'aide du script suivant :

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

Insérez les données dans le tableau comme suit :

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

Modifier le tableau des cours pour ajouter une colonne CourseType

Mettez à jour la table Course pour ajouter la clé étrangère CourseType :

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

Ajoutez des données à la table Course nouvellement modifiée comme suit :

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

Ajouter une nouvelle vue CoursesWithTypes

Ajoutez maintenant une nouvelle vue pour voir tous les cours avec leurs types comme suit :

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

Vérification de la base de données

Affichez la structure de la base de données pour voir les modifications les plus récentes :

Exécutez la vue CoursesWithTypes :

Configurer la version 2 en créant un instantané du schéma de base de données

Créez une autre copie ponctuelle de la structure de la base de données pour marquer la version 2 de la base de données.

Créez un instantané de schéma de base de données et appelez-le TechnicalTraining-Version-002-StudentCourseTrainerCourseType.snap comme suit :

Déploiement de plusieurs versions de base de données

Après la création réussie d'instantanés de schéma de base de données pour les versions 1 et 2, nous pouvons désormais déployer n'importe quelle version dans n'importe quel environnement selon les besoins.

Création d'une base de données de développement à partir de la version 1 de l'instantané de schéma

Cliquez sur Comparaison-> Nouvelle comparaison de schémas depuis la barre de menu dans dbForge Studio for SQL Server :

Définissez ensuite le type de source sur Instantané et localisez l'instantané du schéma de base de données version 1 TechnicalTraining-Version-001-StudentCourseTrainer.snap nous avons créé précédemment et cliquez sur le symbole plus pour créer la base de données cible à la volée :

Tapez le nom de la base de données TechnicalTrainingV1_DEV et cliquez sur OK :

Cliquez sur Suivant :

Cliquez sur Suivant à nouveau pour sélectionner les Options par défaut puis cliquez sur Suivant pour continuer avec les options de mappage de schéma par défaut, puis cliquez sur Comparer :

Synchronisez la source et la cible en cliquant sur l'icône verte au milieu comme indiqué ci-dessous :

Après quelques étapes supplémentaires, cliquez sur Synchroniser :

Ensuite, exécutez le script pour enfin créer le TechnicalTrainingV1_DEV base de données à partir de l'instantané du schéma de base de données représentant la version 1 de la base de données :

Affichez la base de données nouvellement créée qui est une copie de la version 1 de la base de données TechnicalTraining :

Création d'une base de données de développement à partir de la version 2 de l'instantané de schéma

Créez maintenant la version 2 de la base de données en suivant les étapes mentionnées pour créer la version 1 simplement en pointant vers Version 2 Database Schema Snapshot TechnicalTraining-Version-002-StudentCourseTrainerCourseType cette fois :

Comparaison de la version 1 et de la version 2

Comparons rapidement les deux bases de données pour voir les différences.

Toutes nos félicitations! Vous avez réussi à créer plusieurs versions de la base de données via des instantanés de schéma de base de données.

Choses à faire

Vous pouvez désormais facilement utiliser des instantanés de schéma de base de données pour créer et déployer plusieurs versions de la base de données.

  1. Créer plusieurs versions de SQLDevBlogTDD mentionné dans mon article précédent.
  2. Créer plusieurs versions de la base de données avec la réunion de la version 1 Nombre total d'articles par rapport d'auteur exigence et réunion de la version 2 Rapport sur le nombre total d'articles par an suite à mon précédent article.
  3. Lisez mon article précédent L'art d'isoler les dépendances et les données dans les tests unitaires de base de données et voyez si vous pouvez créer deux versions différentes de la base de données via des instantanés de schéma de base de données, l'un avec des tests unitaires tSQLt et l'autre sans tests unitaires tSQLt.

Outil utile :

dbForge Studio for SQL Server – puissant IDE pour la gestion, l'administration, le développement, la création de rapports et l'analyse de données de SQL Server.