Criando e implantando várias versões de banco de dados por meio de instantâneos de esquema

Visão geral

Este artigo fala sobre o uso de instantâneos de esquema de banco de dados para manter diferentes versões de um banco de dados a serem implantados em diferentes ambientes.

Os instantâneos de esquema de banco de dados são cópias pontuais do estado atual do banco de dados que normalmente são usadas para reconciliar as diferenças ao implantar alterações de um ambiente para outro.

Este artigo se concentrará em um cenário específico em que os instantâneos de esquema de banco de dados são mais do que apenas cópias pontuais do banco de dados, em vez de serem usados para criar novas versões de ambientes específicos.

O que é instantâneo do esquema de banco de dados

Um instantâneo de esquema de banco de dados é simplesmente uma cópia pontual salva de um banco de dados.

Em outras palavras, um snapshot de esquema de banco de dados é uma cópia exata da estrutura do banco de dados que não inclui dados em sua forma original.

O esquema do banco de dados refere-se a todos os objetos do banco de dados, incluindo tabelas, visualizações e procedimentos armazenados. Criamos um instantâneo de esquema de banco de dados para congelar as definições de objetos para uso posterior.

Por que o instantâneo do esquema de banco de dados é necessário

Os instantâneos de esquema de banco de dados podem ser usados para os seguintes propósitos:

Copiar um estado existente de um banco de dados para referência futura ou uso futuro.
Versão de um banco de dados por meio de vários instantâneos de esquema de banco de dados.
Criando uma cópia pontual da estrutura do banco de dados para restauração rápida.
Criar uma cópia do esquema de banco de dados de destino antes de implantar novas alterações.
Criar uma cópia estável mais recente do esquema de banco de dados antes de continuar com mais alterações.
Criar e compartilhar alterações no banco de dados com um membro externo da equipe que não pode acessar diretamente o ambiente do banco de dados.
O instantâneo do esquema do banco de dados também pode ser usado para comparar as diferenças entre o trabalho atual e o trabalho realizado no passado.
Os instantâneos de esquema de banco de dados também podem ser usados para publicação desconectada.

Requisito para manter várias versões do banco de dados

Se sua equipe de desenvolvimento de banco de dados recebeu um requisito especial para manter e manter várias versões de banco de dados a serem implantadas em vários ambientes então, uma das soluções é usar instantâneos de esquema de banco de dados para atender ao requisito.

Criando várias versões de banco de dados

Conforme discutido anteriormente, os instantâneos de esquema de banco de dados não são usados apenas como cópias pontuais da estrutura do banco de dados, mas também podem ser usados para criar e implantar várias versões de banco de dados ao mesmo tempo.

Configuração de banco de dados de amostra (Treinamento técnico)

Abra o dbForge Studio para SQL Server ou SSMS (SQL Server Management Studio) para configurar um banco de dados de exemplo chamado TechnicalTraining que contém as informações sobre cursos técnicos, alunos e formadores com as seguintes tabelas:

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

Observe que o banco de dados do TechnicalTraining está estruturado de forma que muitos alunos podem fazer muitos cursos, enquanto cada curso pode ter apenas um instrutor, conforme mostrado abaixo:

Observe que estou usando o dbForge Studio para SQL Server, portanto, a aparência da saída pode ser diferente se você executar o mesmo código no SSMS (SQL Server Management Studio). No entanto, não há diferença entre os scripts e seus resultados.

Preencha o banco de dados usando o seguinte script:

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

Verificação do banco de dados

Clique com o botão direito do mouse em Progresso do Aluno em Visualizações pasta e clique em Recuperar dados ou, alternativamente, digite o seguinte código T-SQL:

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

A saída é a seguinte:

Configurar a versão 1 criando um instantâneo do esquema de banco de dados

Este é o momento de salvar a cópia pontual do esquema do banco de dados, pois a estrutura do banco de dados atual atende aos requisitos da versão 1 do banco de dados.

Criar a versão 1 do instantâneo do esquema

Clique com o botão direito do mouse em Treinamento Técnico banco de dados no Explorador de banco de dados do dbForge Studio para SQL Server (ou você pode usar qualquer ferramenta similar de sua escolha que seja capaz de criar um snapshot de esquema de banco de dados), clique em Tarefas e clique em Criar pasta ou instantâneo de scripts… como mostrado abaixo:

Crie um instantâneo no local desejado e nomeie-o TechnicalTraining-Version-001-StudentCourseTrainer.snap do seguinte modo:

Verifique a versão 1 do instantâneo do esquema

Verifique a pasta para visualizar o instantâneo do esquema de banco de dados criado recentemente da versão 1:

Adicionar nova tabela CourseType

Vamos agora adicionar outra tabela chamada CourseType para o banco de dados existente com a ajuda do seguinte script:

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

Insira os dados na tabela da seguinte forma:

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

Modificar a tabela do curso para adicionar a coluna CourseType

Atualize a tabela Course para adicionar a chave estrangeira 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

Adicione dados à tabela do curso recém-modificada da seguinte forma:

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

Adicionar nova visualização CoursesWithTypes

Agora adicione uma nova visualização para ver todos os cursos com seus tipos da seguinte forma:

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

Verificação do banco de dados

Visualize a estrutura do banco de dados para ver as alterações mais recentes:

Execute a visualização CoursesWithTypes:

Configurar a versão 2 criando um instantâneo do esquema de banco de dados

Crie outra cópia pontual da estrutura do banco de dados para marcar a Versão 2 do banco de dados.

Crie um instantâneo de esquema de banco de dados e chame-o de TechnicalTraining-Version-002-StudentCourseTrainerCourseType.snap do seguinte modo:

Implantando várias versões de banco de dados

Após a criação bem-sucedida de instantâneos de esquema de banco de dados para a versão 1 e a versão 2, agora podemos implantar qualquer versão em qualquer ambiente conforme o requisito.

Criando banco de dados de desenvolvimento a partir do instantâneo de esquema versão 1

Clique em Comparação-> Nova comparação de esquema na barra de menus no dbForge Studio para SQL Server:

Em seguida, defina o tipo de origem como instantâneo e localize o instantâneo do esquema de banco de dados versão 1 TechnicalTraining-Version-001-StudentCourseTrainer.snap criamos anteriormente e clique no símbolo de mais para criar o banco de dados de destino em tempo real:

Digite o nome do banco de dados TechnicalTrainingV1_DEV e clique em OK:

Clique em Avançar :

Clique em Avançar novamente para selecionar as Opções padrão e clique em Avançar para continuar com as opções padrão de Mapeamento de Esquema e clique em Comparar :

Sincronize a origem e o destino clicando no ícone verde no meio, conforme mostrado abaixo:

Após mais algumas etapas, clique emSincronizar :

Em seguida, execute o script para finalmente criar o TechnicalTrainingV1_DEV banco de dados do instantâneo do esquema de banco de dados que representa a versão 1 do banco de dados:

Veja o banco de dados recém-criado que é uma cópia do banco de dados TechnicalTraining versão 1:

Criando banco de dados de desenvolvimento a partir do instantâneo de esquema versão 2

Agora crie a versão 2 do banco de dados seguindo as etapas mencionadas para criar a versão 1 simplesmente apontando para o instantâneo do esquema de banco de dados da versão 2 TechnicalTraining-Version-002-StudentCourseTrainerCourseType desta vez:

Comparando a versão 1 e a versão 2

Vamos comparar rapidamente os dois bancos de dados para ver as diferenças.

Parabéns! Você criou com êxito várias versões do banco de dados por meio de instantâneos de esquema de banco de dados.

Coisas para fazer

Agora você pode usar facilmente instantâneos de esquema de banco de dados para criar e implantar várias versões do banco de dados.

Crie várias versões do SQLDevBlogTDD mencionado no meu artigo anterior.
Crie várias versões do banco de dados com a reunião da versão 1 Número total de artigos por relatório de autor requisito e versão 2 atendendo ao Relatório do número total de artigos por ano seguindo meu artigo anterior.
Veja meu artigo anterior Arte de isolar dependências e dados no teste de unidade de banco de dados e veja se você pode criar duas versões diferentes do banco de dados por meio de instantâneos de esquema de banco de dados, um com testes de unidade tSQLt e outro sem testes de unidade tSQLt.

Ferramenta útil:

dbForge Studio for SQL Server – IDE poderoso para gerenciamento, administração, desenvolvimento, relatório e análise de dados do SQL Server.