Auto-e-mail-system til at sende databaseoversigtsrapport

Databaseovervågning er den vigtigste opgave for enhver databaseadministrator. Store organisationer og virksomheder har flere databaseservere, der er placeret enten i samme datacenter eller i de geografisk forskellige datacentre. Der er mange standardværktøjer til databaseovervågning. Disse værktøjer bruger SQL Servers dynamiske administrationsvisninger og systemlagrede procedurer til at udfylde dataene. Ved at bruge disse DMV'er kan vi oprette vores skræddersyede automatiserede system til at udfylde databasens status og e-maile rapporten.

I denne artikel vil jeg demonstrere, hvordan vi kan bruge den systemlagrede procedure og den linkede server til at udfylde oplysningerne om databaser, der er placeret på forskellige servere, og planlægge jobbet til at sende rapporten.

I denne demo skal jeg udføre følgende opgaver:

1. Opret nødvendige lagrede procedurer på TTI609-VM1 , TTI609-VM2, og TTI412-VM servere til at udfylde oplysninger om databasen, databaseobjekter og SQL-job.
2. Opret en lagret procedure til at udfylde databaseresumé, databaseobjektresumé og SQL-joboversigt fra TTI609-VM1 og TTI609-VM2 servere og gem dem i relaterede tabeller.
3. Opret en SSIS-pakke, som udfører følgende opgaver:
   • • Udfører en lagret procedure ved hjælp af Udfør SQL-scriptopgave .
     • Eksporter data fra SQL-tabeller oprettet på TTI412-VM og gem det på den individuelle fane i en excel-fil.
4. Opret et SQL Server-job for at udføre SSIS-pakken for at udfylde databaseoplysningerne og den lagrede procedure for at e-maile rapporten.

Følgende billede illustrerer demo-opsætningen:

Følgende er listen over lagrede procedurer:

Følgende er listen over tabeller:

Opret lagrede procedurer på begge databaseservere

Som jeg nævnte, skal vi udfylde data fra TTI609-VM1 og TTI609-VM2 servere. De lagrede procedurer, der bruges til at udfylde databasen, forbliver de samme på begge servere.
Så for det første har jeg oprettet en database ved navn DBATools på begge servere. Jeg oprettede en lagret procedure i disse databaser. For at gøre det skal du udføre følgende kode på TTI609-VM1 og TTI609-VM2 servere:

USE [master] 
go 
/****** Object:  Database [DBATools]    Script Date: 10/25/2018 11:25:27 AM ******/ 
CREATE DATABASE [DBATools] containment = none ON PRIMARY ( NAME = N'DBATools', 
filename = 
N'C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\DATA\DBATools.mdf' 
, size = 3264kb, maxsize = unlimited, filegrowth = 1024kb ) log ON ( NAME = 
N'DBATools_log', filename = 
N'C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\DATA\DBATools_log.ldf' 
, size = 816kb, maxsize = 2048gb, filegrowth = 10%) 
go

Opret en lagret procedure med navnet Pull_Database_Information i DBATools database. Denne lagrede procedure udfylder følgende oplysninger om alle databaser, der findes på begge databaseservere.

1. Databasenavn.
2. Databasekompatibilitetsniveau.
3. Status for databasen (ONLINE/OFFLINE/GENDANNELSE/SUSPENDER).
4. Databasegendannelsesmodel (SIMPLE / FULL / BULK-LOGGED).
5. Databasestørrelse i MB.
6. Samlet datafilstørrelse.
7. Brugt datafilstørrelse.
8. Samlet logfilstørrelse.
9. Brugt logfilstørrelse.

Udfør følgende kode iDBATools database for begge databaseservere for at oprette den lagrede procedure:

USE DBAtools 
go 
CREATE PROCEDURE Pull_Database_Information 
AS 
  BEGIN 
      IF Object_id('tempdb.dbo.#DBSize') IS NOT NULL 
        DROP TABLE #dbsize 

      CREATE TABLE #dbsize 
        ( 
           database_id         INT PRIMARY KEY, 
           data_file_used_size DECIMAL(18, 2), 
           log_file_used_size  DECIMAL(18, 2) 
        ) 

      DECLARE @SQLCommand NVARCHAR(max) 

      SELECT @SQLCommand = Stuff((SELECT '     USE [' + d.NAME + ']     INSERT INTO #DBSize (database_id, data_file_used_size, log_File_used_size)     SELECT           DB_ID()         , SUM(CASE WHEN [type] = 0 THEN space_used END)         , SUM(CASE WHEN [type] = 1 THEN space_used END)     FROM (         SELECT s.[type], space_used = SUM(FILEPROPERTY(s.name, ''SpaceUsed'') * 8. / 1024)         FROM sys.database_files s         GROUP BY s.[type]     ) t;' 
                                  FROM   sys.databases d 
                                  WHERE  d.[state] = 0 
                                  FOR xml path(''), type).value('.', 
                           'NVARCHAR(MAX)'), 
                           1, 2, 
                                  '') 

      EXEC sys.Sp_executesql 
        @SQLCommand 

      SELECT d.database_id         AS 'Database ID', 
             d.NAME                AS 'Database Name', 
             d.state_desc          AS 'Database State', 
             d.recovery_model_desc AS 'Recovery Model', 
             t.total_db_size       AS 'Database Size', 
             t.data_file_size      AS 'Data File Size', 
             s.data_file_used_size AS 'Data File Used', 
             t.log_file_size       AS 'Log file size', 
             s.log_file_used_size  AS 'Log File Used' 
      FROM   (SELECT database_id, 
                     log_file_size = Cast(Sum(CASE 
                                                WHEN [type] = 1 THEN size 
                                              END) * 8. / 1024 AS DECIMAL(18, 2) 
                                     ), 
                     data_file_size = Cast(Sum(CASE 
                                                 WHEN [type] = 0 THEN size 
                                               END) * 8. / 1024 AS 
                                           DECIMAL(18, 2)) 
                     , 
                     total_DB_size = Cast( 
                     Sum(size) * 8. / 1024 AS DECIMAL(18, 2)) 
              FROM   sys.master_files 
              GROUP  BY database_id) t 
             JOIN sys.databases d 
               ON d.database_id = t.database_id 
             LEFT JOIN #dbsize s 
                    ON d.database_id = s.database_id 
      ORDER  BY t.total_db_size DESC 
  END

For det andet skal du oprette lagrede procedurer med navnet Pull_Database_Objects i DBATools database. Denne lagrede procedure gentager alle databaserne i begge databaseservere og udfylder antallet af alle databaseobjekter. Den udfylder følgende kolonner:

1. Server/værtsnavn.
2. Databasenavn.
3. Type af databaseobjekt (tabel / lagret procedure / SQL-skaleringsfunktioner / begrænsninger osv...)
4. Samlet antal databaseobjekter.

Udfør følgende kode i DBATools database på begge databaseservere for at oprette den lagrede procedure:

USE dbatools 
go 

CREATE PROCEDURE [Pull_database_objects] 
AS 
  BEGIN 
      CREATE TABLE #finalsummery 
        ( 
           id           INT IDENTITY (1, 1), 
           databasename VARCHAR(350), 
           objecttype   VARCHAR(200), 
           totalobjects INT 
        ) 

      DECLARE @SQLCommand NVARCHAR(max) 
      DECLARE @I INT=0 
      DECLARE @DBName VARCHAR(350) 
      DECLARE @DBCount INT 

      CREATE TABLE #databases 
        ( 
           NAME VARCHAR(350) 
        ) 

      INSERT INTO #databases 
                  (NAME) 
      SELECT NAME 
      FROM   sys.databases 
      WHERE  database_id > 4 
             AND NAME NOT IN ( 'ReportServer', 'reportservertempdb' ) 

      SET @DBCount=(SELECT Count(*) 
                    FROM   #databases) 

      WHILE ( @DBCount > @I ) 
        BEGIN 
            SET @DBName=(SELECT TOP 1 NAME 
                         FROM   #databases) 
            SET @SQLCommand='             Insert Into #FinalSummery (DatabaseName,ObjectType,TotalObjects)             Select              ''' + @DBName 
                            + ''',             Case                 when Type=''TR'' then ''SQL DML trigger''              when Type=''FN'' then ''SQL scalar function''              when Type=''D'' then ''DEFAULT (constraint or stand-alone)''              when Type=''PK'' then ''PRIMARY KEY constraint''              when Type=''P'' then ''SQL Stored Procedure''              when Type=''U'' then ''Table (user-defined)''              when Type=''V''  then ''View''              when Type=''X'' then ''Extended stored procedure''             End As ObjectType,              Count(Name)TotalObjects from ' + @DBName 
                            + '.sys.all_objects               group by type' 

            EXEC Sp_executesql 
              @SQLCommand 

            DELETE FROM #databases 
            WHERE  NAME = @DBName 

            SET @[email protected] + 1 
        END 

      SELECT Host_name() AS 'Server Name', 
             databasename, 
             objecttype, 
             totalobjects, 
             Getdate()   AS 'ReportDate' 
      FROM   #finalsummery 
      WHERE  objecttype IS NOT NULL 

      DROP TABLE #finalsummery 
  END

Opret lagrede procedurer med navnet Pull_SQLJob_Information i DBATools database. Denne lagrede procedure gentager hele databaseserveren og udfylder oplysningerne om alle SQL-jobs og deres status. Den udfylder følgende kolonner:

1. Server/værtsnavn.
2. SQL-jobnavn.
3. Ejer af SQL Job.
4. Jobkategori.
5. Beskrivelse af job.
6. Jobstatus (Aktiveret/deaktiveret)
7. En dato for jobskabelse.
8. Dato for jobændring.
9. Jobplanlagt status.
10. Plannavn.
11. Dato og klokkeslæt for sidste udførelse
12. Sidste udførelsesstatus.

Udfør følgende kode iDBATools database på begge databaseservere for at oprette den lagrede procedure:

CREATE PROCEDURE Pull_sqljob_information 
AS 
  BEGIN 
      SELECT Host_name()       AS 'Server Name', 
             a.NAME            AS 'Job Name', 
             d.NAME            AS Owner, 
             b.NAME            AS Category, 
             a.description     AS Description, 
             CASE a.enabled 
               WHEN 1 THEN 'Yes' 
               WHEN 0 THEN 'No' 
             END               AS 'IsEnabled', 
             a.date_created    AS CreatedDate, 
             a.date_modified   AS ModifiedDate, 
             CASE 
               WHEN f.schedule_uid IS NULL THEN 'No' 
               ELSE 'Yes' 
             END               AS 'Scheduled?', 
             f.NAME            AS JobScheduleName, 
             Max(Cast( 
      Stuff(Stuff(Cast(g.run_date AS VARCHAR), 7, 0, '-'), 5, 0, '-') 
           + ' ' 
           + 
Stuff(Stuff(Replace(Str(g.run_time, 6, 0), ' ', '0'), 5, 0, ':'), 3, 0, ':') 
AS DATETIME)) AS [LastRun], 
CASE g.run_status 
WHEN 0 THEN 'Failed' 
WHEN 1 THEN 'Success' 
WHEN 2 THEN 'Retry' 
WHEN 3 THEN 'Canceled' 
WHEN 4 THEN 'In progress' 
END               AS Status 
FROM   msdb.dbo.sysjobs AS a 
       INNER JOIN msdb.dbo.sysjobhistory g 
               ON a.job_id = g.job_id 
       LEFT JOIN msdb.dbo.syscategories AS b 
              ON a.category_id = b.category_id 
       LEFT JOIN msdb.dbo.sysjobsteps AS c 
              ON a.job_id = c.job_id 
                 AND a.start_step_id = c.step_id 
       LEFT JOIN msdb.sys.database_principals AS d 
              ON a.owner_sid = d.sid 
       LEFT JOIN msdb.dbo.sysjobschedules AS e 
              ON a.job_id = e.job_id 
       LEFT JOIN msdb.dbo.sysschedules AS f 
              ON e.schedule_id = f.schedule_id 
GROUP  BY a.NAME, 
          d.NAME, 
          b.NAME, 
          a.description, 
          a.enabled, 
          f.schedule_uid, 
          f.NAME, 
          a.date_created, 
          a.date_modified, 
          g.run_status 
ORDER  BY a.NAME 
END

Opret lagrede procedurer, linket server og tabeller på den centrale server

Når procedurerne er blevet oprettet på TTI609-VM1 og TTI609-VM2 databaseservere, oprette nødvendige procedurer og tabeller på den centrale server (TTI412-VM ).

Jeg oprettede en separat database med navnet MonitoringDashboard på TTI412-VM server. Udfør følgende kode for at oprette en database på den centrale server.

USE [master] 
go 

/****** Object:  Database [MonitoringDashboard]    Script Date: 10/25/2018 2:44:09 PM ******/ 

CREATE DATABASE [MonitoringDashboard] containment = none ON PRIMARY ( NAME = 
N'MonitoringDashboard', filename = 
N'E:\MS_SQL\SQL2017_Data\MonitoringDashboard.mdf', size = 8192kb, maxsize = 
unlimited, filegrowth = 65536kb ) log ON ( NAME = N'MonitoringDashboard_log', 
filename = N'E:\MS_SQL\SQL2017_Log\MonitoringDashboard_log.ldf', size = 8192kb, 
maxsize = 2048gb, filegrowth = 65536kb ) 

go

Når databasen er oprettet, skal du oprette en lagret procedure, som bruger LINKED Server til at udføre en procedure på TTI609-VM1 og TTI609-VM2 databaseservere. Udfør følgende kode i "master"-databasen på TTI412-VM databaseserver for at oprette en sammenkædet server:

Script 1:Opret linket server TTI609-VM1

USE [master] 
go 
/****** Object:  LinkedServer [TTI609-VM1]    Script Date: 10/25/2018 2:49:28 PM ******/ 
EXEC master.dbo.Sp_addlinkedserver 
  @server = N'TTI609-VM1', 
  @srvproduct=N'SQL Server' 

/* For security reasons the linked server remote logins password is changed with ######## */ 
EXEC master.dbo.Sp_addlinkedsrvlogin 
  @rmtsrvname=N'TTI609-VM1', 
  @useself=N'False', 
  @locallogin=NULL, 
  @rmtuser=N'sa', 
  @rmtpassword='########' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'collation compatible', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'data access', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'dist', 
  @optvalue=N'false' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'rpc', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'rpc out', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'connect timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'query timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'use remote collation', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'remote proc transaction promotion', 
  @optvalue=N'false' 

go

Script 2:Opret linket server TTI609-VM2

USE [master] 

go 

/****** Object:  LinkedServer [TTI609-VM2]    Script Date: 10/25/2018 2:55:29 PM ******/ 
EXEC master.dbo.Sp_addlinkedserver 
  @server = N'TTI609-VM2', 
  @srvproduct=N'SQL Server' 

/* For security reasons the linked server remote logins password is changed with ######## */ 
EXEC master.dbo.Sp_addlinkedsrvlogin 
  @rmtsrvname=N'TTI609-VM2', 
  @useself=N'False', 
  @locallogin=NULL, 
  @rmtuser=N'sa', 
  @rmtpassword='########' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'collation compatible', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'data access', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'dist', 
  @optvalue=N'false' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'rpc', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'rpc out', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'connect timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'collation name', 
  @optvalue=NULL 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'query timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'use remote collation', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'remote proc transaction promotion', 
  @optvalue=N'false' 

go

Opret en lagret procedure og tabeller

Når den linkede server er blevet oprettet, skal vi oprette tre tabeller med navnet Database_Object_Summery , Database_Summery , og SQL_Job_List i Monitoring Dashboard database. Disse tabeller gemmer oplysninger udfyldt af Generer_Database_Information lagret procedure og senere dataene, gemt i de tabeller, der vil blive brugt til at generere en rapport i excel.

Udfør følgende kode for at oprette SQL_Job_List tabel:

USE [MonitoringDashboard] 
go 

CREATE TABLE [dbo].[sql_job_list] 
  ( 
     [id]             [INT] IDENTITY(1, 1) NOT NULL, 
     [servername]     [VARCHAR](250) NULL, 
     [jobname]        [VARCHAR](250) NULL, 
     [jobowner]       [VARCHAR](250) NULL, 
     [jobcategory]    [VARCHAR](250) NULL, 
     [jobdescription] [VARCHAR](250) NULL, 
     [jobstatus]      [VARCHAR](50) NULL, 
     [createdate]     [DATETIME] NULL, 
     [modifieddate]   [DATETIME] NULL, 
     [isscheduled]    [VARCHAR](5) NULL, 
     [schedulename]   [VARCHAR](250) NULL, 
     [reportdate]     [DATETIME] NULL 
  ) 
ON [PRIMARY] 

go 

ALTER TABLE [dbo].[sql_job_list] 
  ADD DEFAULT (Getdate()) FOR [ReportDate] 

go

Udfør følgende kode for at oprette lst_dbserverne tabel:

USE [MonitoringDashboard] 

go 

CREATE TABLE [dbo].[lst_dbservers] 
  ( 
     [id]         [INT] IDENTITY(1, 1) NOT NULL, 
     [servername] [VARCHAR](50) NOT NULL, 
     [addeddate]  [DATETIME] NOT NULL, 
     PRIMARY KEY CLUSTERED ( [id] ASC )WITH (pad_index = OFF, 
     statistics_norecompute = OFF, ignore_dup_key = OFF, allow_row_locks = on, 
     allow_page_locks = on) ON [PRIMARY], 
     UNIQUE NONCLUSTERED ( [servername] 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 [dbo].[lst_dbservers] 
  ADD DEFAULT (Getdate()) FOR [AddedDate] 

go

Udfør følgende kode for at oprette Database_Summery tabel:

USE [MonitoringDashboard] 
go 
CREATE TABLE [dbo].[database_summery] 
  ( 
     [id]                 [INT] IDENTITY(1, 1) NOT NULL, 
     [servername]         [VARCHAR](150) NULL, 
     [databaseid]         [INT] NULL, 
     [databasename]       [VARCHAR](250) NULL, 
     [databasestatus]     [VARCHAR](50) NULL, 
     [recoverymodel]      [VARCHAR](50) NULL, 
     [compatibilitylevel] [INT] NULL, 
     [databasecreatedate] [DATE] NULL, 
     [databasecreatedby]  [VARCHAR](150) NULL, 
     [dbsize]             [NUMERIC](10, 2) NULL, 
     [datafilesize]       [NUMERIC](10, 2) NULL, 
     [datafileused]       [NUMERIC](10, 2) NULL, 
     [logfilesize]        [NUMERIC](10, 2) NULL, 
     [logfileused]        [NUMERIC](10, 2) NULL, 
     [reportdate]         [DATETIME] NULL 
  ) 
ON [PRIMARY] 
go 

ALTER TABLE [dbo].[database_summery] 
  ADD DEFAULT (Getdate()) FOR [ReportDate] 
go

Udfør følgende kode for at oprette Database_Object_Summery tabel:

USE [MonitoringDashboard] 

go 

CREATE TABLE [dbo].[database_object_summery] 
  ( 
     [id]           [INT] IDENTITY(1, 1) NOT NULL, 
     [servername]   [VARCHAR](250) NULL, 
     [databasename] [VARCHAR](250) NULL, 
     [objecttype]   [VARCHAR](50) NULL, 
     [objectcount]  [INT] NULL, 
     [reportdate]   [DATETIME] NULL 
  ) 
ON [PRIMARY] 

go 

ALTER TABLE [dbo].[database_object_summery] 
  ADD DEFAULT (Getdate()) FOR [ReportDate] 

go

Når tabellerne er oprettet, skal du oprette en lagret procedure med navnetGenerer_database_oplysninger på Monitoring Dashboard database. Ved at bruge "RPC" udfører den lagrede procedurer, oprettet påTTI609-VM1 og TTI609-VM2 databaseservere til at udfylde dataene.

Udfør følgende kode for at oprette en lagret procedure:

Create PROCEDURE Generate_database_information 
AS 
  BEGIN 
      /*Cleanup*/ 
      TRUNCATE TABLE database_object_summery 
      TRUNCATE TABLE database_summery 
      TRUNCATE TABLE sql_job_list 

      DECLARE @ServerCount INT 
      DECLARE @i INT =0 
      DECLARE @SQLCommand_Object_Summery NVARCHAR(max) 
      DECLARE @SQLCommand_Database_Information NVARCHAR(max) 
      DECLARE @SQLCommand_SQL_Job_Information NVARCHAR(max) 
      DECLARE @servername VARCHAR(100) 

      CREATE TABLE #db_server_list 
        ( 
           servername VARCHAR(100) 
        ) 

      INSERT INTO #db_server_list 
                  (servername) 
      SELECT servername 
      FROM   lst_dbservers 

      SET @ServerCount= (SELECT Count(servername) 
                         FROM   #db_server_list) 

      WHILE ( @ServerCount > @i ) 
        BEGIN 
            SET @servername=(SELECT TOP 1 servername 
                             FROM   #db_server_list) 
            SET @SQLCommand_Object_Summery = 
'insert into Database_Object_Summery (ServerName,DatabaseName,ObjectType,ObjectCount,ReportDate) exec [' 
+ @servername 
+ '].DBATools.dbo.[Pull_Database_Objects]' 
    SET @SQLCommand_Database_Information = 
'insert into Database_Summery (ServerName,DatabaseID,DatabaseName,DatabaseStatus,Recoverymodel,CompatibilityLevel,DatabaseCreateDate,DatabaseCreatedBy,DBSize,DataFileSize,DataFileUsed,LogFileSize,LogFileUsed) exec [' 
+ @servername 
+ '].DBATools.dbo.[Pull_Database_Information]' 
    SET @SQLCommand_SQL_Job_Information = 
'insert into SQL_Job_List (ServerName,JobName,JobOwner,Jobcategory,JobDescription,JobStatus,CreateDate,ModifiedDate,IsScheduled,ScheduleName) exec [' 
+ @servername 
+ '].DBATools.dbo.[Pull_SQLJob_Information]' 

    EXEC Sp_executesql 
      @SQLCommand_Object_Summery 

    EXEC Sp_executesql 
      @SQLCommand_Database_Information 

    EXEC Sp_executesql 
      @SQLCommand_SQL_Job_Information 

    DELETE FROM #db_server_list 
    WHERE  servername = @servername 

    SET @[email protected] + 1 
END 
END

Når proceduren er oprettet, skal du oprette en SSIS-pakke for at eksportere data til en Excel-fil.

Opret SSIS-pakke for at eksportere data i excel-fil

I mine tidligere artikler forklarede jeg trinene til at konfigurere dataflowopgaverne, OLEDB-forbindelser og Excel-forbindelser, og derfor springer jeg denne del over.

For at eksportere data til en Excel-fil skal du åbne SQL Server Data-værktøjer og oprette et nyt SSIS-projekt med navnet Export_Database_Information.

Når projektet er oprettet, skal du trække og slippeUdfør SQL-opgave til Kontrolflow vinduet og omdøb det til Fyld data fra servere . Se følgende billede:

Dobbeltklik på Udfør SQL-opgave (Udfyld data fra server). Execute SQL Task Editor dialogboksen åbnes for at konfigurere SQL-forbindelse. Se følgende billede:

I Forbindelse arkiveret, skal du vælge OLEDB forbindelsesstrengen og i SQL-erklæringen felt, skal du angive følgende forespørgsel:

USE monitoringdashboard 
go 
EXEC Generate_database_information

Klik på OK for at lukke dialogboksen.

På Kontrolflow skærm, træk og slip Data Flow Task fra SSIS Toolbox og omdøb den til Generer rapport. Se følgende billede:

Dobbeltklik for at åbneDataflow vindue.

Som jeg nævnte tidligere, er Generer_Database_Information procedure indsætter output fra databaseserverne i følgende tabeller:

1. Database_Object_Summery
2. Database_Summery
3. SQL_Jobliste

Jeg oprettede en Excel-fil, der har tre regneark. Følgende tabeller viser tilknytningen af ​​SQL-tabellerne og Excel-regnearket.

I Dataflow vindue, træk og slip tre ADO.Net-kilder og tre Excel-destinationer. Se følgende billede:

Dobbeltklik på Objektoversigt y (ADO.NET-kilde) i ADO.NET-kilde Redaktør.

1. Vælg TTI412-VM\SQL2017Monitoring Dashboard fra ADO.NET Connection Manager rullemenu.
2. Vælg Tabel eller Vis fra Dataadgangstilstand rullemenu.
3. Vælg Database_Object_Summery fra Navn på tabellen eller visningen rullemenu.

Dobbeltklik på Databaseoplysninger (ADO.NET Source) i ADO.NET Source Editor .

1. Vælg "TTI412-VM\SQL2017MonitoringDashboard ” fra ADO.NET-forbindelsesadministratoren rullemenu.
2. Vælg Tabel eller Vis fra Dataadgangstilstand rullemenu.
3. Vælg "Database_Summery ” fra navnet på tabellen eller visningen rullemenu.

Dobbeltklik på SQL-job (ADO.NET Source) i ADO.NET Source Editor .

1. Vælg TTI412-VM\SQL2017Monitoring Dashboard i ADO.NET Connection Manager.
2. Vælg Tabel eller Vis fra Dataadgangstilstand rullemenu.
3. Vælg SQL_Job_List i Navn på tabellen eller visningen rullemenu.

Træk og slip nu tre Excel-destinationer fra SSIS Toolbox. Se følgende billede:

Når destinationer er blevet kopieret, skal du trække den blå pil under ADO.Net-kilden og slippe den på Excel-destinationen. Gør det samme for alle. Se følgende billede:

Dobbeltklik på Excel-objektoversigt (ADO.NET-kilde) iExcel Destination Editor .

1. Vælg Excel Connection Manager fra Excel-forbindelsesadministratoren rullemenu.
2. Vælg Table eller View fra Dataadgangstilstand rullemenu.
3. Vælg Object Summery$ fra Excel-arkets navn rullemenu.

Som jeg nævnte, er kolonnenavnene på SQL-tabellen og Excel-kolonnerne de samme, og kortlægningen vil derfor blive udført automatisk. Klik på Mapping at kortlægge kolonnerne. Se følgende billede:

Dobbeltklik på Excel-databaseoplysninger (Excel-destination) i Excel-destinationseditor .

1. Vælg Excel Connection Manager fra Excel-forbindelsesadministratoren rullemenu.
2. Vælg Table eller View fra Dataadgangstilstand rullemenu.
3. Vælg Databaseinformation$ fra Excel-arkets navn rullemenu.

Som jeg nævnte, er kolonnenavnene på SQL-tabellen og Excel-kolonnerne de samme, og kortlægningen vil derfor blive udført automatisk. Klik på Mapping at kortlægge kolonnerne. Se følgende billede:

Dobbeltklik på Excel SQL-job (Excel Destination) iExcel Destination Editor .

1. Vælg Excel Connection Manager fra Excel-forbindelsesadministratoren rullemenu.
2. Vælg Table eller View fra Dataadgangstilstand rullemenu.
3. Vælg "SQL Jobs$ fra Navnet på Excel-arket rullemenu.

Som jeg nævnte, er kolonnenavnene på SQL-tabellen og Excel-kolonnerne de samme, og kortlægningen vil derfor blive udført automatisk. Klik på Mapping at kortlægge kolonnerne. Se følgende billede:

Opret et SQL-job for at e-maile databaserapporten

Når pakken er oprettet, skal du oprette et SQL-job for at udføre følgende aktiviteter:

1. Kør SSIS-pakken for at udfylde data fra alle servere.
2. Send databaserapporten til det nødvendige team.

I SQL Job skal vi oprette to trin. Det første trin vil udføre SSIS-pakken, og det andet trin vil udføre proceduren for at sende en e-mail.

For at oprette et SQL-job skal du åbne SSMS>> SQL Server Agent>> Højreklik på Nyt SQL-job .

Om det nye job guiden skal du vælge trinnet og klik på Nej w. I Nyt job-trinet dialogboksen i Trin navn tekstboks, angiv det ønskede navn, vælg SQL Server Integration Services Package fra Type drop-down boks. Angiv en placering af SSIS-pakken i pakketeksten boks. Se følgende billede:

Klik på OK for at lukke Nyt jobtrin .

Opret endnu et jobtrin, som vil udføre en lagret procedure for at e-maile rapporten. Den bruger en systemprocedure til at sende en e-mail. SSIS-pakken kopierer databaseinformationen på en bestemt placering, og angiv derfor den fulde sti til excel-filen i parameteren @file_attachments for sp_send_dbmail gemt procedure.

For at oprette den lagrede procedure skal du udføre følgende kode i DBATools database af Central Server:

CREATE PROCEDURE Send_database_report 
AS 
  BEGIN 
      DECLARE @ProfileName VARCHAR(150) 

      SET @ProfileName = (SELECT NAME 
                          FROM   msdb..sysmail_profile 
                          WHERE  profile_id = 7) 

      DECLARE @lsMessage NVARCHAR(max) 

      SET @lsMessage = '<p style="font-family:Arial; font-size:10pt">   Hello Support,   Please find attached database summery report.      ' + '</p>' 

      EXEC msdb.dbo.Sp_send_dbmail 
        @recipients='[email protected]', 
        @[email protected], 
        @subject='Database Summery Report', 
        @file_attachments= 
      'C:\Users\Administrator\Desktop\Database_Information.xlsx', 
        @copy_recipients='', 
        @blind_copy_recipients='', 
        @body_format='HTML', 
        @[email protected] 
  END

Once the procedure is created, add a new SQL Job step. Click New . In the New Job Step dialog box, provide a Job Step name, and select Transact-SQL script (T-SQL) from the Type drop-down boks. In the Command Text box, write the following code:

USE DBAtools 
Go 

EXEC Send_database_report

Se følgende billede:

Click OK to close the wizard. Now to configure Job Schedule , select Schedules on the New Job vindue. Click New to add a schedule.

In the New Job Schedule dialog box, provide the desired name in the Name text box, choose frequency and time. Se følgende billede:

Close OK to close the New Job Schedule and in the New Job window, click on OK to close the dialog box.

Now, to test the SQL Job, right-click the Email Database Report SQL job and click Start Job at Step .

In the result of successful completion of the SQL Job, you will receive an email with the database report. Se følgende billede:

Oversigt

In this article I have covered as follows:

1. How to populate information of the databases located on remote DB server.
2. Create an SSIS package to populate database information and export it to excel file
3. Create a multi-step SQL job to generate the report by executing an SSIS package and email the report.