Auto-e-postsystem för att skicka databassammanfattningsrapport

Databasövervakning är det viktigaste jobbet för alla databasadministratörer. Stora organisationer och företag har flera databasservrar som finns antingen i samma datacenter eller i geografiskt olika datacenter. Det finns många standardverktyg för databasövervakning. Dessa verktyg använder SQL Servers dynamiska hanteringsvyer och systemlagrade procedurer för att fylla i data. Med dessa DMV:er kan vi skapa vårt skräddarsydda automatiska system för att fylla i databasens status och skicka rapporten via e-post.

I den här artikeln kommer jag att visa hur vi kan använda den systemlagrade proceduren och den länkade servern för att fylla i informationen från databaser som finns på olika servrar och schemalägga jobbet för att skicka rapporten.

I den här demon kommer jag att utföra följande uppgifter:

1. Skapa nödvändiga lagrade procedurer på TTI609-VM1 , TTI609-VM2, och TTI412-VM servrar för att fylla i information om databasen, databasobjekt och SQL-jobb.
2. Skapa en lagrad procedur för att fylla i databassammanfattning, databasobjektsammanfattning och SQL-jobbsammanfattning från TTI609-VM1 och TTI609-VM2 servrar och lagra dem i relaterade tabeller.
3. Skapa ett SSIS-paket som utför följande uppgifter:
   • • Kör en lagrad procedur med Execute SQL Script Task .
     • Exportera data från SQL-tabeller skapade på TTI412-VM och lagra den på den individuella fliken i en excel-fil.
4. Skapa ett SQL Server-jobb för att köra SSIS-paketet för att fylla i databasinformationen och den lagrade proceduren för att skicka rapporten via e-post.

Följande bild illustrerar demoinställningarna:

Följande är listan över lagrade procedurer:

Följande är listan över tabeller:

Skapa lagrade procedurer på båda databasservrarna

Som jag nämnde kommer vi att fylla i data från TTI609-VM1 och TTI609-VM2 servrar. De lagrade procedurerna som används för att fylla i databasen kommer att förbli desamma på båda servrarna.
Så för det första har jag skapat en databas med namnet DBATools på båda servrarna. Jag skapade en lagrad procedur i dessa databaser. För att göra det, kör följande kod på TTI609-VM1 och TTI609-VM2 servrar:

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

Skapa en lagrad procedur med namnet Pull_Database_Information i DBATools databas. Denna lagrade procedur fyller i följande information om alla databaser som finns på båda databasservrarna.

1. Databasnamn.
2. Databaskompatibilitetsnivå.
3. Databasens tillstånd (ONLINE/OFFLINE/ÅTERSTÄLLNING/AVSTÄNDA).
4. Databasåterställningsmodell (ENKEL / FULL / BULK-LOGGAD).
5. Databasstorlek i MB.
6. Total datafilstorlek.
7. Använd datafilstorlek.
8. Total loggfilstorlek.
9. Använd loggfilstorlek.

Kör följande kod iDBATools databas för båda databasservrarna för att skapa den lagrade proceduren:

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

För det andra, skapa lagrade procedurer med namnet Pull_Database_Objects i DBATools databas. Denna lagrade procedur itererar genom alla databaser inom båda databasservrarna och fyller i antalet databasobjekt. Den fyller i följande kolumner:

1. Server/värdnamn.
2. Databasnamn.
3. Typ av databasobjekt (tabell / lagrad procedur / SQL-skalningsfunktioner / begränsningar etc...)
4. Totalt antal databasobjekt.

Kör följande kod i DBATools databas på båda databasservrarna för att skapa den lagrade proceduren:

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

Skapa lagrade procedurer med namnet Pull_SQLJob_Information i DBATools databas. Denna lagrade procedur itererar genom alla databasservrar och fyller i informationen om alla SQL-jobb och deras status. Den fyller i följande kolumner:

1. Server/värdnamn.
2. SQL-jobbnamn.
3. Ägare av SQL Job.
4. Jobbkategori.
5. Beskrivning av jobb.
6. Status för jobb (Aktiverad / inaktiverad)
7. Ett datum då jobb skapades.
8. Jobbets ändringsdatum.
9. Status för schemalagd jobb.
10. Schemanamn.
11. Senaste körningsdatum och tid
12. Status för senaste körning.

Kör följande kod iDBATools databas på båda databasservrarna för att skapa den lagrade proceduren:

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

Skapa lagrade procedurer, länkad server och tabeller på den centrala servern

När procedurerna har skapats på TTI609-VM1 och TTI609-VM2 databasservrar, skapa nödvändiga procedurer och tabeller på den centrala servern (TTI412-VM ).

Jag skapade en separat databas som heter MonitoringDashboard på TTI412-VM server. Kör följande kod för att skapa en databas på den centrala servern.

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 har skapats, skapa en lagrad procedur som använder LINKED Server för att utföra en procedur på TTI609-VM1 och TTI609-VM2 databasservrar. Kör följande kod i "master"-databasen för TTI412-VM databasserver för att skapa en länkad server:

Skript 1:Skapa länkad 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

Skript 2:Skapa länkad 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

Skapa en lagrad procedur och tabeller

När den länkade servern har skapats måste vi skapa tre tabeller med namnet Database_Object_Summery , Databas_Sommar och SQL_Job_List i Monitoring Dashboard databas. Dessa tabeller lagrar information som fylls i av Generera_Databas_Information lagrad procedur och senare data, lagrade i de tabeller som kommer att användas för att generera en rapport i excel.

Kör följande kod för att skapa SQL_Job_List tabell:

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

Kör följande kod för att skapa lst_dbservers tabell:

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

Kör följande kod för att skapa Databas_Summery tabell:

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

Kör följande kod för att skapa Database_Object_Summery tabell:

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 tabellerna har skapats skapar du en lagrad procedur med namnetGenera_databasinformation på Monitoring Dashboard databas. Genom att använda "RPC" exekverar den lagrade procedurer, skapade påTTI609-VM1 och TTI609-VM2 databasservrar för att fylla i data.

Kör följande kod för att skapa en lagrad procedur:

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 har skapats skapar du ett SSIS-paket för att exportera data till en Excel-fil.

Skapa SSIS-paket för att exportera data i excel-fil

I mina tidigare artiklar förklarade jag stegen för att konfigurera dataflödesuppgifterna, OLEDB-anslutningar och Excel-anslutningar, därför hoppar jag över den här delen.

För att exportera data till en Excel-fil, öppna SQL Server Data-verktyg och skapa ett nytt SSIS-projekt med namnet Export_Database_Information.

När projektet har skapats, dra och släppUtför SQL-uppgift till Kontrollflöde fönstret och byt namn på det till Fylla data från servrar . Se följande bild:

Dubbelklicka på Execute SQL Task (Fyll i data från servern). Execute SQL Task Editor dialogrutan öppnas för att konfigurera SQL-anslutning. Se följande bild:

I Anslutning arkiverat, välj OLEDB anslutningssträng och i SQL-satsen fältet, ange följande fråga:

USE monitoringdashboard 
go 
EXEC Generate_database_information

Klicka på OK för att stänga dialogrutan.

På Kontrollflöde dra och släpp Data Flow Task från SSIS Toolbox och byt namn på den till Generera rapport. Se följande bild:

Dubbelklicka för att öppnaDataflödet fönster.

Som jag nämnde tidigare, Generera_databasinformation proceduren infogar utdata från databasservrarna i följande tabeller:

1. Databas_Object_Summery
2. Databas_Summery
3. SQL_Job_List

Jag skapade en Excel-fil som har tre kalkylblad. Följande tabeller visar mappningen av SQL-tabellerna och Excel-arbetsbladet.

I Dataflödet fönster, dra och släpp tre ADO.Net-källor och tre Excel-destinationer. Se följande bild:

Dubbelklicka på Objektsammanfattning y (ADO.NET-källa) i ADO.NET-källa Redaktör.

1. Välj TTI412-VM\SQL2017Monitoring Dashboard från ADO.NET-anslutningshanteraren rullgardinsmenyn.
2. Välj Tabell eller Visa från Dataåtkomstläge rullgardinsmenyn.
3. Välj Databas_Object_Summery från Namn på tabellen eller vyn rullgardinsmenyn.

Dubbelklicka på Databasinformation (ADO.NET Source) i ADO.NET Source Editor .

1. Välj “TTI412-VM\SQL2017MonitoringDashboard ” från ADO.NET-anslutningshanteraren rullgardinsmenyn.
2. Välj Tabell eller Visa från Dataåtkomstläge rullgardinsmenyn.
3. Välj "Databas_Sommar ” från Namn på tabellen eller vyn rullgardinsmenyn.

Dubbelklicka på SQL-jobb (ADO.NET Source) i ADO.NET Source Editor .

1. Välj TTI412-VM\SQL2017Monitoring Dashboard i ADO.NET-anslutningshanteraren.
2. Välj Tabell eller Visa från Dataåtkomstläget rullgardinsmenyn.
3. Välj SQL_Job_List i Namn på tabellen eller vyn rullgardinsmenyn.

Dra och släpp nu tre Excel-destinationer från SSIS Toolbox. Se följande bild:

När destinationer har kopierats, dra den blå pilen under ADO.Net-källan och släpp den på Excel-destinationen. Gör samma sak för alla. Se följande bild:

Dubbelklicka på Excel-objektsammanfattning (ADO.NET-källa) iExcel Destination Editor .

1. Välj Excel Connection Manager från Excel-anslutningshanteraren rullgardinsmenyn.
2. Välj Table eller View från Dataåtkomstläge rullgardinsmenyn.
3. Välj Objekt Summery$ från Excel-arkets namn rullgardinsmenyn.

Som jag nämnde är kolumnnamnen för SQL-tabellen och Excel-kolumnerna samma, därför kommer mappningen att göras automatiskt. Klicka på Mapping för att kartlägga kolumnerna. Se följande bild:

Dubbelklicka påExcel Database Information (Excel Destination) i Excel Destination Editor .

1. Välj Excel Connection Manager från Excel-anslutningshanteraren rullgardinsmenyn.
2. Välj Table eller View från Dataåtkomstläge rullgardinsmenyn.
3. Välj Databasinformation$ från Excel-arkets namn rullgardinsmenyn.

Som jag nämnde är kolumnnamnen för SQL-tabellen och Excel-kolumnerna samma, därför kommer mappningen att göras automatiskt. Klicka på Mapping för att kartlägga kolumnerna. Se följande bild:

Dubbelklicka på Excel SQL Jobs (Excel Destination) iExcel Destination Editor .

1. Välj Excel Connection Manager från Excel-anslutningshanteraren rullgardinsmenyn.
2. Välj Table eller View från Dataåtkomstläge rullgardinsmenyn.
3. Välj "SQL Jobs$ från namnet på Excel-arket rullgardinsmenyn.

Som jag nämnde är kolumnnamnen för SQL-tabellen och Excel-kolumnerna samma, därför kommer mappningen att göras automatiskt. Klicka på Mapping för att kartlägga kolumnerna. Se följande bild:

Skapa ett SQL-jobb för att e-posta databasrapporten

När paketet har skapats skapar du ett SQL-jobb för att utföra följande aktiviteter:

1. Kör SSIS-paketet för att fylla i data från alla servrar.
2. E-posta databasrapporten till det team som krävs.

I SQL Job måste vi skapa två steg. Det första steget kommer att exekvera SSIS-paketet och det andra steget kommer att utföra proceduren för att skicka ett e-postmeddelande.

För att skapa ett SQL-jobb, öppna SSMS>> SQL Server Agent>> Högerklicka på Nytt SQL-jobb .

Om det nya jobbet guiden väljer du Steg och klicka på Nej w. I steget Nytt jobb dialogrutan i Steg namn textrutan, ange önskat namn, välj SQL Server Integration Services Package från Typ rullgardinsmenyn. Ange en plats för SSIS-paketet i pakettexten låda. Se följande bild:

Klicka på OK för att stänga Nytt jobbsteg .

Skapa ytterligare ett jobbsteg som kommer att exekvera en lagrad procedur för att e-posta rapporten. Den använder en systemprocedur för att skicka ett e-postmeddelande. SSIS-paketet kopierar databasinformationen på en specifik plats, och ange därför den fullständiga sökvägen till excel-filen i parametern @file_attachments för sp_send_dbmail lagrad procedur.

För att skapa den lagrade proceduren, kör följande kod i DBATools databas för 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 box. In the Command Text box, write the following code:

USE DBAtools 
Go 

EXEC Send_database_report

See the following image:

Click OK to close the wizard. Now to configure Job Schedule , select Schedules on the New Job window. 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. See the following image:

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. See the following image:

Summary

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.