Einführung
Sie können viele Anleitungen zum Sichern und Wiederherstellen von Datenbanken finden. In diesem zeigen wir, wie dies mit den Standardmitteln von MS SQL Server geschehen kann.
Dieses Beispiel behandelt eine Reihe von Ansätzen – von der Überprüfung der Datenbankintegrität vor der Sicherung bis hin zur Wiederherstellung der Datenbank aus einer zuvor erstellten Sicherungskopie.
Die Lösung
Schauen wir uns zunächst den Gesamtalgorithmus an, den wir zum Sichern einer Datenbank verwenden:
1) Definieren, welche Datenbanken gesichert werden müssen
2) Prüfen der Integrität der ausgewählten Datenbanken
3) Erstellen einer Sicherung (vollständige, differenzielle oder Transaktionsprotokollkopie) für jede der ausgewählten Datenbanken
4) Überprüfen der erstellten Sicherungskopien
5) Komprimieren der Transaktionsprotokolle (falls erforderlich)
Nachfolgend finden Sie ein Implementierungsbeispiel dieses Algorithmus.
Um zu definieren, welche Datenbanken gesichert werden müssen, erstellen wir die folgende Tabelle:
USE [DB_NAME] GO SET ANSI_NULLS ON GO SET QUOTED_IDENTIFIER ON GO CREATE TABLE [srv].[BackupSettings]( [DBID] [int] NOT NULL, [FullPathBackup] [nvarchar](255) NOT NULL, [DiffPathBackup] [nvarchar](255) NULL, [LogPathBackup] [nvarchar](255) NULL, [InsertUTCDate] [datetime] NOT NULL, CONSTRAINT [PK_BackupSettings] PRIMARY KEY CLUSTERED ( [DBID] ASC )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] ) ON [PRIMARY]; GO ALTER TABLE [srv].[BackupSettings] ADD CONSTRAINT [DF_BackupSettings_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate]; GO
Die Datenbankkennung befindet sich in der ersten Spalte, „FullPathBackup“ enthält den Pfad für die vollständige Sicherungskopieerstellung (z. B. „disk:\…\“) und DiffPathBackup und LogPathBackup enthalten vollständige Pfade für die Erstellung von Differenz- und Transaktionsprotokollkopien bzw. Wenn die Spalten DiffPathBackup oder LogPathBackup leer sind, wird die differenzielle und/oder Transaktionsprotokollkopie für diese Datenbank nicht erstellt.
Wir können auch eine Darstellung basierend auf dieser Tabelle erstellen:
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [srv].[vBackupSettings]
as
SELECT [DBID]
,DB_Name([DBID]) as [DBName]
,[FullPathBackup]
,[DiffPathBackup]
,[LogPathBackup]
,[InsertUTCDate]
FROM [srv].[BackupSettings];
GO Mit dieser Darstellung können Sie effektiv überprüfen, welche Datenbanken am Sicherungsvorgang teilnehmen.
Lassen Sie uns nun eine Darstellung erstellen, die Datenbankdateiinformationen aus der Systemdarstellung sys.master_files anzeigt:
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [inf].[ServerDBFileInfo] as
SELECT @@Servername AS Server ,
File_id ,--DB file identifier. The base value for file_id is 1
Type_desc ,--Type file description
Name as [FileName] ,--DB logical file name
LEFT(Physical_Name, 1) AS Drive ,--Drive flag of the DB file location
Physical_Name ,--Full file name in the OS
RIGHT(physical_name, 3) AS Ext ,--File extension
Size as CountPage, --Current file size in 8Kb pages
round((cast(Size*8 as float))/1024,3) as SizeMb, --File size in Mb
round((cast(Size*8 as float))/1024/1024,3) as SizeGb, --File size in Gb
case when is_percent_growth=0 then Growth*8 else 0 end as Growth, --File growth in 8Kb pages
case when is_percent_growth=0 then round((cast(Growth*8 as float))/1024,3) end as GrowthMb, --File growth in Mb
case when is_percent_growth=0 then round((cast(Growth*8 as float))/1024/1024,3) end as GrowthGb, --File growth in Gb
case when is_percent_growth=1 then Growth else 0 end as GrowthPercent, --File growth in percent
is_percent_growth, --Percent growth attribute
database_id,
DB_Name(database_id) as [DB_Name],
State,--File state
state_desc as StateDesc,--File state description
is_media_read_only as IsMediaReadOnly,--File is located on the drive as read-only (0 - and for writing)
is_read_only as IsReadOnly,--file is flagged as read-only (0 - and for writing)
is_sparse as IsSpace,--Sparse file
is_name_reserved as IsNameReserved,--1 - Remote file name, accessible for use.
--It is necessary to get a log backup before using the same name (name or physical_name arguments) again for a new file
--0 - Filename, inaccessible for use
create_lsn as CreateLsn,--Transaction registration number in the log (LSN) which was used to create the file
drop_lsn as DropLsn,--LSN which was used to delete the file
read_only_lsn as ReadOnlyLsn,--LSN which was used by the file group containing the file to change the "read and write" type to "read-only" (the latest change)
read_write_lsn as ReadWriteLsn,--LSN which was used by the file group containing the file to change the "read-only" type to "read and write" (the latest change)
differential_base_lsn as DifferentialBaseLsn,--A base for differential backup copies. Data extents which were changed after the LSN is included into the differential backup.
differential_base_guid as DifferentialBaseGuid,--Unique identifier of the base backup copy which will be used to create a differential copy.
differential_base_time as DifferentialBaseTime,--The time corresponding to differential_base_lsn
redo_start_lsn as RedoStartLsn,--LSN used to determine the start of the next redo
--Is NULL, except for the cases in which state = RESTORING or state = RECOVERY_PENDING
redo_start_fork_guid as RedoStartForkGuid,--Unique identifier for the restoration fork point
--first_fork_guid argument value of the next restored backup copy should be equal to this value
redo_target_lsn as RedoTargetLsn,--LSN which serves as a stop point for an "online" mode redo in this file
--Is NULL, except for the cases in which state = RESTORING or state = RECOVERY_PENDING
redo_target_fork_guid as RedoTargetForkGuid,--Restoration fork on which the container can be restored. Used along with redo_target_lsn
backup_lsn as BackupLsn--LSN of the most recent data or the file's differential backup copy
FROM sys.master_files--database_files;
GO Um vollständige Sicherungskopien zu erstellen, implementieren wir die folgende gespeicherte Prozedur:
[expand title =”Code „]
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunFullBackupDB]
@ClearLog bit=1 --specifies whether the transaction log size should be reduced
AS
BEGIN
/*
Creating a full DB backup copy and checking the DB for integrity beforehand
*/
SET NOCOUNT ON;
declare @dt datetime=getdate();
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @tbllog table(
[DBName] [nvarchar](255) NOT NULL,
[FileNameLog] [nvarchar](255) NOT NULL
);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[FullPathBackup] [nvarchar](255) NOT NULL
);
--Retrieving DB name and full paths for full backup copy creation
insert into @tbl (
[DBName]
,[FullPathBackup]
)
select DB_NAME([DBID])
,[FullPathBackup]
from [srv].[BackupSettings];
--Retrieving the DB name and names of the according transaction logs (as one DB can have multiple logs)
insert into @tbllog([DBName], [FileNameLog])
select t.[DBName], tt.[FileName] as [FileNameLog]
from @tbl as t
inner join [inf].[ServerDBFileInfo] as tt on t.[DBName]=DB_NAME(tt.[database_id])
where tt.[Type_desc]='LOG';
--sequentially processing each of the DBs we got earlier
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[FullPathBackup]
from @tbl;
set @[email protected]+N'_Full_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))--+N'_'
--+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @[email protected]@sqldat.com+N'.bak';
--checking the DB for integrity
set @sql=N'DBCC CHECKDB(N'+N''''[email protected]+N''''+N') WITH NO_INFOMSGS';
exec(@sql);
--executing the backup copy creation procedure
set @sql=N'BACKUP DATABASE ['[email protected]+N'] TO DISK = N'+N''''[email protected]+N''''+
N' WITH NOFORMAT, NOINIT, NAME = N'+N''''[email protected]+N''''+
N', CHECKSUM, STOP_ON_ERROR, SKIP, REWIND, COMPRESSION, STATS = 10;';
exec(@sql);
--checking the backup copy we created
select @backupSetId = position
from msdb..backupset where [email protected]
and backup_set_id=(select max(backup_set_id) from msdb..backupset where [email protected]);
set @sql=N'Verification error. Backup copy information for "'[email protected]+'" database not found.';
if @backupSetId is null begin raiserror(@sql, 16, 1) end
else
begin
set @sql=N'RESTORE VERIFYONLY FROM DISK = N'+''''[email protected]+N''''+N' WITH FILE = '+cast(@backupSetId as nvarchar(255));
exec(@sql);
end
--compressing the DB transaction logs
if(@ClearLog=1)
begin
while(exists(select top(1) 1 from @tbllog where [DBName][email protected]))
begin
select top(1)
@FileNameLog=FileNameLog
from @tbllog
where [email protected];
set @sql=N'USE ['[email protected]+N'];'+N' DBCC SHRINKFILE (N'+N''''[email protected]+N''''+N' , 0, TRUNCATEONLY)';
exec(@sql);
delete from @tbllog
where [email protected]
and [email protected];
end
end
delete from @tbl
where [DBName][email protected];
end
END
GO [/expandieren]
Gemäß dem Code können wir sehen, dass dieses Verfahren eine Lösung für die verbleibenden Schritte des Algorithmus zum Erstellen einer Sicherungskopie bietet.
Prozeduren, die Differential- und Transaktionsprotokollkopien erstellen, werden auf ähnliche Weise implementiert:
[expand title =”Code „]
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunDiffBackupDB]
@ClearLog bit=1 --specifies if the transaction log size should be reduced
AS
BEGIN
/*
Creating a differential DB backup copy
*/
SET NOCOUNT ON;
declare @dt datetime=getdate();
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[DiffPathBackup] [nvarchar](255) NOT NULL
);
declare @tbllog table(
[DBName] [nvarchar](255) NOT NULL,
[FileNameLog] [nvarchar](255) NOT NULL
);
--Retrieving the DB name and full paths for creating differential backup copies
insert into @tbl (
[DBName]
,[DiffPathBackup]
)
select DB_NAME([DBID])
,[DiffPathBackup]
from [srv].[BackupSettings]
where [DiffPathBackup] is not null;
--Retrieving DB name and the full names of the according transaction log files (as one DB can have multiple logs)
insert into @tbllog([DBName], [FileNameLog])
select t.[DBName], tt.[FileName] as [FileNameLog]
from @tbl as t
inner join [inf].[ServerDBFileInfo] as tt on t.[DBName]=DB_NAME(tt.[database_id])
where tt.[Type_desc]='LOG';
--sequentially processing each of the DBs we got earlier
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[DiffPathBackup]
from @tbl;
set @[email protected]+N'_Diff_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))+N'_'
+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @[email protected]@sqldat.com+N'.bak';
--checking the DB for integrity
set @sql=N'DBCC CHECKDB(N'+N''''[email protected]+N''''+N') WITH NO_INFOMSGS';
exec(@sql);
--executing the backup procedure
set @sql=N'BACKUP DATABASE ['[email protected]+N'] TO DISK = N'+N''''[email protected]+N''''+
N' WITH DIFFERENTIAL, NOFORMAT, NOINIT, NAME = N'+N''''[email protected]+N''''+
N', CHECKSUM, STOP_ON_ERROR, SKIP, REWIND, COMPRESSION, STATS = 10;';
exec(@sql);
--checking the backup copy we just created
select @backupSetId = position
from msdb..backupset where [email protected]
and backup_set_id=(select max(backup_set_id) from msdb..backupset where [email protected]);
set @sql=N'Verification error. Backup copy information for "'[email protected]+'" database not found.';
if @backupSetId is null begin raiserror(@sql, 16, 1) end
else
begin
set @sql=N'RESTORE VERIFYONLY FROM DISK = N'+''''[email protected]+N''''+N' WITH FILE = '+cast(@backupSetId as nvarchar(255));
exec(@sql);
end
--compressing the DB transaction logs
if(@ClearLog=1)
begin
while(exists(select top(1) 1 from @tbllog where [DBName][email protected]))
begin
select top(1)
@FileNameLog=FileNameLog
from @tbllog
where [email protected];
set @sql=N'USE ['[email protected]+N'];'+N' DBCC SHRINKFILE (N'+N''''[email protected]+N''''+N' , 0, TRUNCATEONLY)';
exec(@sql);
delete from @tbllog
where [email protected]
and [email protected];
end
end
delete from @tbl
where [DBName][email protected];
end
END
GO [/expandieren]
Da das Überprüfen von Datenbanken auf Integrität viele Ressourcen beansprucht, können wir es weglassen, während wir eine differenzielle Sicherungskopie erstellen.
[expand title =”Code „]
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunLogBackupDB]
@ClearLog bit=1 --specifies if the transaction log size should be reduced
AS
BEGIN
/*
Backing up the DB transaction log
*/
SET NOCOUNT ON;
declare @dt datetime=getdate();
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[LogPathBackup] [nvarchar](255) NOT NULL
);
declare @tbllog table(
[DBName] [nvarchar](255) NOT NULL,
[FileNameLog] [nvarchar](255) NOT NULL
);
--Retrieving DB names and full paths for creating backup copies of transaction logs with a non-simple recovery model (full or bulk-logged). System DBs are also excluded
insert into @tbl (
[DBName]
,[LogPathBackup]
)
select DB_NAME(b.[DBID])
,b.[LogPathBackup]
from [srv].[BackupSettings] as b
inner join sys.databases as d on b.[DBID]=d.[database_id]
where d.recovery_model<3
and DB_NAME([DBID]) not in (
N'master',
N'tempdb',
N'model',
N'msdb',
N'ReportServer',
N'ReportServerTempDB'
)
and [LogPathBackup] is not null;
--Retrieving DB name and the full names of the according transaction log files (as one DB can have multiple logs)
insert into @tbllog([DBName], [FileNameLog])
select t.[DBName], tt.[FileName] as [FileNameLog]
from @tbl as t
inner join [inf].[ServerDBFileInfo] as tt on t.[DBName]=DB_NAME(tt.[database_id])
where tt.[Type_desc]='LOG';
--sequentially processing each of the DBs we got earlier
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[LogPathBackup]
from @tbl;
set @[email protected]+N'_Log_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))+N'_'
+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @[email protected]@sqldat.com+N'.trn';
--executing the backup procedure
set @sql=N'BACKUP LOG ['[email protected]+N'] TO DISK = N'+N''''[email protected]+N''''+
N' WITH NOFORMAT, NOINIT, NAME = N'+N''''[email protected]+N''''+
N', CHECKSUM, STOP_ON_ERROR, SKIP, REWIND, COMPRESSION, STATS = 10;';
exec(@sql);
--Checking the transaction log backup copy we just created
select @backupSetId = position
from msdb..backupset where [email protected]
and backup_set_id=(select max(backup_set_id) from msdb..backupset where [email protected]);
set @sql=N'Verification error. Backup copy information for "'[email protected]+'" database not found.';
if @backupSetId is null begin raiserror(@sql, 16, 1) end
else
begin
set @sql=N'RESTORE VERIFYONLY FROM DISK = N'+''''[email protected]+N''''+N' WITH FILE = '+cast(@backupSetId as nvarchar(255));
exec(@sql);
end
--compressing the DB transaction logs
if(@ClearLog=1)
begin
while(exists(select top(1) 1 from @tbllog where [DBName][email protected]))
begin
select top(1)
@FileNameLog=FileNameLog
from @tbllog
where [email protected];
set @sql=N'USE ['[email protected]+N'];'+N' DBCC SHRINKFILE (N'+N''''[email protected]+N''''+N' , 0, TRUNCATEONLY)';
exec(@sql);
delete from @tbllog
where [email protected]
and [email protected];
end
end
delete from @tbl
where [DBName][email protected];
end
END
GO [/expandieren]
Wie oben erwähnt, ist das Überprüfen von Datenbanken auf Integrität eine ressourcenintensive Aufgabe. Zusammen mit der Tatsache, dass Transaktionslog-Sicherungskopien normalerweise ziemlich oft erstellt werden müssen, gibt uns dies einen Grund, die Integritätsprüfung beim Erstellen einer Transaktionslog-Kopie wegzulassen.
Bitte denken Sie auch daran, dass in regelmäßigen Abständen vollständige Sicherungskopien der Datenbanken „master“, „msdb“ und „model“ erstellt werden müssen.
Um den Erstellungsprozess der Sicherungskopie zu automatisieren, müssen Sie nur einen Aufruf der zuvor implementierten Prozeduren in den Windows-Taskplaner, Agent-Jobs oder einen ähnlichen verfügbaren Dienst platzieren.
Sie müssen die Anrufhäufigkeit für jedes dieser Verfahren individuell basierend auf Lastspitzen, Aktivitätsplateaus usw. einstellen.
Der grundlegende Ansatz ist wie folgt:
1) Einmal täglich eine vollständige Sicherungskopie erstellen
2) Alle 2–4 Stunden differenzielle Sicherungskopien erstellen
3) Alle 5–60 Minuten Sicherungskopien des Transaktionsprotokolls erstellen
Bitte beachten Sie, dass in der Regel Datenbanken am Ausfallsicherheits- und Schnellzugriffssystem teilnehmen. Und wenn der spätere Sicherungskopien von Transaktionsprotokollen verwendet, ist es äußerst wichtig, den Vorgang nicht zu stören. Genauer gesagt bedeutet dies, dass Transaktionsprotokollkopien nicht von mehreren verschiedenen Prozessen erstellt werden sollten – wenn dies geschieht, geht die Sicherungssequenz dieser Kopien verloren.
Hier haben wir Beispiele dafür gesehen, wie jede Datenbank nacheinander verarbeitet wird, eine nach der anderen. Wir können jedoch eine parallele Verarbeitung in der Produktionsumgebung erreichen – so dass mehrere Sicherungskopien gleichzeitig erstellt werden können. Dies kann auf verschiedene Arten angegangen werden. Beispielsweise durch Aufrufen der folgenden gespeicherten Prozedur:
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [inf].[RunAsyncExecute]
(
@sql nvarchar(max),
@jobname nvarchar(57) = null,
@database nvarchar(128)= null,
@owner nvarchar(128) = null
)
AS BEGIN
/*
Asynchronous package execution via the Agent's jobs
RunAsyncExecute - asynchronous execution of T-SQL command or stored prodecure
2012 Antonin Foller, Motobit Software, www.motobit.com
http://www.motobit.com/tips/detpg_async-execute-sql/
*/
SET NOCOUNT ON;
declare @id uniqueidentifier;
--Create unique job name if the name is not specified
if (@jobname is null) set @jobname= '';
set @jobname = @jobname + '_async_' + convert(varchar(64),NEWID());
if (@owner is null) set @owner = 'sa';
--Create a new job, get job ID
execute msdb..sp_add_job @jobname, @[email protected], @[email protected] OUTPUT;
--Specify a job server for the job
execute msdb..sp_add_jobserver @[email protected];
--Specify a first step of the job - the SQL command
--(@on_success_action = 3 ... Go to next step)
execute msdb..sp_add_jobstep @[email protected], @step_name='Step1', @command = @sql,
@database_name = @database, @on_success_action = 3;
--Specify next step of the job - delete the job
declare @deletecommand varchar(200);
set @deletecommand = 'execute msdb..sp_delete_job @job_name='''[email protected]+'''';
execute msdb..sp_add_jobstep @[email protected], @step_name='Step2', @command = @deletecommand;
--Start the job
execute msdb..sp_start_job @[email protected];
END
GO Hier wird Asynchronität erreicht, indem die Agent-Jobs dynamisch erstellt, ausgeführt und anschließend gelöscht werden.
Sehen wir uns nun den allgemeinen Algorithmus zum Wiederherstellen von Datenbanken aus Sicherungskopien an, die zuvor in einer anderen/Testumgebung erstellt wurden:
1) Festlegen, welche Datenbanken wiederhergestellt werden sollen und wo sich ihre Sicherungskopien befinden
2) Wiederherstellen der Datenbanken
3) Prüfen der wiederhergestellten Datenbanken auf Integrität
Nun sehen wir uns eine Implementierung eines Algorithmus an, der eine Datenbank aus einer vollständigen Sicherungskopie wiederherstellt. Für eine differenzielle Kopie ist das Verfahren ähnlich – der einzige Unterschied besteht darin, dass zuerst eine vollständige Sicherungskopie wiederhergestellt werden muss, gefolgt von der differenziellen Kopie.
Um zu definieren, welche Datenbanken wiederhergestellt werden sollen, sowie den Speicherort ihrer Sicherungskopien, erstellen wir zwei Tabellen wie unten gezeigt:
USE [DB_NAME] GO SET ANSI_NULLS ON GO SET QUOTED_IDENTIFIER ON GO CREATE TABLE [srv].[RestoreSettings]( [DBName] [nvarchar](255) NOT NULL, [FullPathRestore] [nvarchar](255) NOT NULL, [DiffPathRestore] [nvarchar](255) NOT NULL, [LogPathRestore] [nvarchar](255) NOT NULL, [InsertUTCDate] [datetime] NOT NULL, CONSTRAINT [PK_RestoreSettings] PRIMARY KEY CLUSTERED ( [DBName] ASC )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] ) ON [PRIMARY]; GO ALTER TABLE [srv].[RestoreSettings] ADD CONSTRAINT [DF_RestoreSettings_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate]; GO
Der Zweck der Spalten ist hier analog zu denen aus der Tabelle [srv].[BackupSettings]. Der einzige Unterschied besteht darin, dass der vollständige Pfad verwendet wird, um die Sicherungskopien für die Wiederherstellung zu finden, und nicht, um neue zu erstellen.
USE [DB_NAME] GO SET ANSI_NULLS ON GO SET QUOTED_IDENTIFIER ON GO CREATE TABLE [srv].[RestoreSettingsDetail]( [Row_GUID] [uniqueidentifier] NOT NULL, [DBName] [nvarchar](255) NOT NULL, [SourcePathRestore] [nvarchar](255) NOT NULL, TargetPathRestore [nvarchar](255) NOT NULL, [Ext] [nvarchar](255) NOT NULL, [InsertUTCDate] [datetime] NOT NULL, CONSTRAINT [PK_RestoreSettingsDetail] PRIMARY KEY CLUSTERED ( [Row_GUID] ASC )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] ) ON [PRIMARY]; GO ALTER TABLE [srv].[RestoreSettingsDetail] ADD CONSTRAINT [DF_RestoreSettingsDetail_Row_GUID] DEFAULT (newid()) FOR [Row_GUID]; GO ALTER TABLE [srv].[RestoreSettingsDetail] ADD CONSTRAINT [DF_RestoreSettingsDetail_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate]; GO
Diese Tabelle wird benötigt, um die vollständigen Dateinamen der wiederherzustellenden Datenbank zu definieren, die dann für die weitere Übertragung verwendet werden (z. B. [SourcePathRestore]='Logical file name' und [TargetPathRestore]='disk:\…\Physical file name ', während [Ext]='Dateierweiterung')
Tatsächlich können wir logische Namen der Datenbankdateien mit der folgenden Abfrage definieren:
RESTORE FILELISTONLY FROM DISK ='disk:\...\backup copy.BAK';
Informationen über Sicherungskopien, die sich in einer Datei befinden, können auf folgende Weise abgerufen werden:
RESTORE HEADERONLY FROM DISK='disk:\...\backup copy.BAK';
Als nächstes haben wir eine Implementierung einer gespeicherten Prozedur, die zum Wiederherstellen einer Datenbank aus einer vollständigen Sicherungskopie und zum Prüfen auf Datenintegrität verwendet wird:
[expand title =”Code „]
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunFullRestoreDB]
AS
BEGIN
/*
Recovering a DB from a full backup copy and checking the DB for integrity
*/
SET NOCOUNT ON;
declare @dt datetime=DateAdd(day,-2,getdate());
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @SourcePathRestore nvarchar(255);
declare @TargetPathRestore nvarchar(255);
declare @Ext nvarchar(255);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[FullPathRestore] [nvarchar](255) NOT NULL
);
declare @tbl_files table (
[DBName] [nvarchar](255) NOT NULL,
[SourcePathRestore] [nvarchar](255) NOT NULL,
[TargetPathRestore] [nvarchar](255) NOT NULL,
[Ext] [nvarchar](255) NOT NULL
);
--retrieving a list of DB names and the paths to full backup copies
insert into @tbl (
[DBName]
,[FullPathRestore]
)
select [DBName]
,[FullPathRestore]
from [srv].[RestoreSettings];
--retrieving detailed info about the new DB files location
insert into @tbl_files (
[DBName]
,[SourcePathRestore]
,[TargetPathRestore]
,[Ext]
)
select [DBName]
,[SourcePathRestore]
,[TargetPathRestore]
,[Ext]
from [srv].[RestoreSettingsDetail];
--processing each of the DBs we got earlier
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[FullPathRestore]
from @tbl;
set @[email protected]+N'_Full_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))--+N'_'
--+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @[email protected]@sqldat.com+N'.bak';
--creating a backup query and executing it
set @sql=N'RESTORE DATABASE ['[email protected]+N'_Restore] FROM DISK = N'+N''''[email protected]+N''''+
N' WITH FILE = 1,';
while(exists(select top(1) 1 from @tbl_files where [DBName][email protected]))
begin
select top(1)
@SourcePathRestore=[SourcePathRestore],
@TargetPathRestore=[TargetPathRestore],
@Ext=[Ext]
from @tbl_files
where [DBName][email protected];
set @[email protected]+N' MOVE N'+N''''[email protected]+N''''+N' TO N'+N''''[email protected]+N'_Restore.'[email protected]+N''''+N',';
delete from @tbl_files
where [DBName][email protected]
and [SourcePathRestore][email protected]
and [Ext][email protected];
end
set @[email protected]+N' NOUNLOAD, REPLACE, STATS = 5';
exec(@sql);
--checking the DB for integrity
set @sql=N'DBCC CHECKDB(N'+N''''[email protected]+'_Restore'+N''''+N') WITH NO_INFOMSGS';
exec(@sql);
delete from @tbl
where [DBName][email protected];
end
END [/expandieren]
Um festzulegen, welche vollständige Sicherungskopie für die Wiederherstellung verwendet werden soll, wird ein speziell strukturierter Dateiname verwendet:
Um diesen Datenbankwiederherstellungsprozess zu automatisieren, sollte der Aufruf der von uns implementierten gespeicherten Prozedur in den Windows-Taskplaner, Agent-Jobs oder einen ähnlichen verfügbaren Dienst platziert werden.
Sie können die neuesten Datenbank-Sicherungskopien anhand der folgenden Darstellung anzeigen:
USE [DB_NAME]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE VIEW [inf].[vServerLastBackupDB] as
with backup_cte as
(
select
bs.[database_name],
backup_type =
case bs.[type]
when 'D' then 'database'
when 'L' then 'log'
when 'I' then 'differential'
else 'other'
end,
bs.[first_lsn],
bs.[last_lsn],
bs.[backup_start_date],
bs.[backup_finish_date],
cast(bs.[backup_size] as decimal(18,3))/1024/1024 as BackupSizeMb,
rownum =
row_number() over
(
partition by bs.[database_name], type
order by bs.[backup_finish_date] desc
),
LogicalDeviceName = bmf.[logical_device_name],
PhysicalDeviceName = bmf.[physical_device_name],
bs.[server_name],
bs.[user_name]
FROM msdb.dbo.backupset bs
INNER JOIN msdb.dbo.backupmediafamily bmf
ON [bs].[media_set_id] = [bmf].[media_set_id]
)
select
[server_name] as [ServerName],
[database_name] as [DBName],
[user_name] as [USerName],
[backup_type] as [BackupType],
[backup_start_date] as [BackupStartDate],
[backup_finish_date] as [BackupFinishDate],
[BackupSizeMb], --uncompressed size
[LogicalDeviceName],
[PhysicalDeviceName],
[first_lsn] as [FirstLSN],
[last_lsn] as [LastLSN]
from backup_cte
where rownum = 1; Das Ergebnis
In diesem Leitfaden haben wir uns die Implementierung eines automatisierten Backup-Prozesses auf einem Server und die anschließende Wiederherstellung auf einem anderen (z. B. einem Testserver) angesehen.
Diese Methode ermöglicht es uns, den Erstellungsprozess der Sicherungskopien zu automatisieren, die Sicherungskopien durch Wiederherstellung zu überprüfen und die oben gezeigten Prozesse zu optimieren.
Quellen:
Backup
Restore
Backupset
CHECKDB
SHRINKFILE
sys.master_files
