Sistema di posta elettronica automatica per inviare il rapporto di riepilogo del database

Il monitoraggio del database è il lavoro più essenziale di qualsiasi amministratore di database. Le grandi organizzazioni e aziende dispongono di più server di database che si trovano nello stesso data center o in data center geograficamente diversi. Esistono molti strumenti standard per il monitoraggio del database. Tali strumenti utilizzano le viste a gestione dinamica di SQL Server e la stored procedure di sistema per popolare i dati. Utilizzando questi DMV, possiamo creare il nostro sistema automatizzato personalizzato per popolare lo stato del database e inviare il rapporto tramite e-mail.

In questo articolo, dimostrerò come possiamo utilizzare la procedura memorizzata di sistema e il server collegato per popolare le informazioni dei database situati su server diversi e pianificare il lavoro per inviare il rapporto.

In questa demo, eseguirò le seguenti attività:

1. Crea le stored procedure richieste su TTI609-VM1 , TTI609-VM2, e TTI412-VM server per popolare le informazioni del database, degli oggetti del database e dei lavori SQL.
2. Crea una procedura memorizzata per popolare il riepilogo del database, il riepilogo dell'oggetto del database e il riepilogo del processo SQL da TTI609-VM1 e TTI609-VM2 server e archiviarli in tabelle correlate.
3. Crea un pacchetto SSIS che esegua le seguenti attività:
   • • Esegue una procedura memorizzata utilizzando Esegui attività script SQL .
     • Esportare i dati dalle tabelle SQL create su TTI412-VM e salvalo nella scheda individuale di un file excel.
4. Crea un processo SQL Server per eseguire il pacchetto SSIS per popolare le informazioni sul database e una procedura archiviata per inviare il report tramite posta elettronica.

L'immagine seguente illustra la configurazione demo:

Di seguito è riportato l'elenco delle stored procedure:

Di seguito è riportato l'elenco delle tabelle:

Crea stored procedure su entrambi i server di database

Come accennato, popoleremo i dati dal TTI609-VM1 e TTI609-VM2 server. Le stored procedure utilizzate per popolare il database rimarranno le stesse in entrambi i server.
Per prima cosa, ho creato un database chiamato DBATools su entrambi i server. Ho creato una procedura memorizzata in quei database. Per farlo, esegui il codice seguente su TTI609-VM1 e TTI609-VM2 server:

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

Crea una procedura memorizzata denominata Pull_Database_Information in DBATools Banca dati. Questa procedura memorizzata popola le seguenti informazioni di tutti i database esistenti su entrambi i server di database.

1. Nome database.
2. Livello di compatibilità del database.
3. Stato del database (ONLINE/OFFLINE/RIPRISTINO/SOSPENSIONE).
4. Modello di ripristino del database (SEMPLICE / COMPLETO / BULK-LOGGED).
5. Dimensioni database in MB.
6. Dimensione totale del file di dati.
7. Dimensione del file di dati utilizzata.
8. Dimensione totale del file di registro.
9. Dimensione del file di registro utilizzata.

Esegui il codice seguente in DBATools database di entrambi i server di database per creare la procedura memorizzata:

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

In secondo luogo, crea stored procedure denominate Pull_Database_Objects in DBATools Banca dati. Questa procedura memorizzata scorre tutti i database all'interno di entrambi i server di database e popola il conteggio di tutti gli oggetti di database. Popola le seguenti colonne:

1. Nome server/host.
2. Nome database.
3. Tipo di oggetto database (Tabella / Stored procedure / Funzioni SQL Scaler / Vincoli ecc…)
4. Numero totale di oggetti di database.

Esegui il codice seguente in DBATools database su entrambi i server di database per creare la procedura memorizzata:

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

Crea stored procedure denominate Pull_SQLJob_Information in DBATools Banca dati. Questa procedura memorizzata esegue un'iterazione in tutto il server di database e popola le informazioni di tutti i lavori SQL e dei relativi stati. Popola le seguenti colonne:

1. Nome server/host.
2. Nome processo SQL.
3. Proprietario del lavoro SQL.
4. Categoria di lavoro.
5. Descrizione del lavoro.
6. Stato del lavoro (Abilitato/disabilitato)
7. Una data di creazione del lavoro.
8. Data di modifica del lavoro.
9. Stato del lavoro pianificato.
10. Nome programma.
11. Data e ora dell'ultima esecuzione
12. Stato dell'ultima esecuzione.

Esegui il codice seguente in DBATools database su entrambi i server di database per creare la procedura memorizzata:

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

Crea Stored procedure, Linked Server e tabelle sul server centrale

Una volta create le procedure su TTI609-VM1 e TTI609-VM2 server di database, creare le procedure e le tabelle richieste sul server centrale (TTI412-VM ).

Ho creato un database separato denominato MonitoringDashboard su TTI412-VM server. Eseguire il codice seguente per creare un database sul server centrale.

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

Una volta creato il database, creare una stored procedure che utilizzi LINKED Server per eseguire una procedura sul TTI609-VM1 e TTI609-VM2 server di database. Eseguire il codice seguente nel database "master" del TTI412-VM server di database per creare un server collegato:

Script 1:crea server collegato 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:crea server collegato 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

Crea una stored procedure e tabelle

Una volta creato il server collegato, dobbiamo creare tre tabelle denominate Database_Object_Summery , Database_Estate e SQL_Job_List nel MonitoringDashboard Banca dati. Queste tabelle memorizzano le informazioni popolate da Generate_Database_Information stored procedure e successivamente i dati, archiviati in quelle tabelle che verranno utilizzate per generare un report in excel.

Esegui il codice seguente per creare SQL_Job_List tabella:

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

Esegui il codice seguente per creare gli lst_dbservers tabella:

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

Esegui il codice seguente per creare il Database_Summery tabella:

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

Esegui il codice seguente per creare il Database_Object_Summery tabella:

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

Una volta create le tabelle, creare una stored procedure denominata Generate_Database_Information nella Dashboard di monitoraggio Banca dati. Utilizzando “RPC”, esegue le stored procedure, create sul TTI609-VM1 e TTI609-VM2 server di database per popolare i dati.

Eseguire il codice seguente per creare una stored 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

Una volta creata la procedura, crea un pacchetto SSIS per esportare i dati in un file Excel.

Crea pacchetto SSIS per esportare dati in file excel

Nei miei articoli precedenti, ho spiegato i passaggi per configurare le attività del flusso di dati, le connessioni OLEDB e le connessioni Excel, quindi ho saltato questa parte.

Per esportare i dati in un file Excel, apri gli strumenti dati di SQL Server e crea un nuovo progetto SSIS denominato Export_Database_Information.

Una volta creato il progetto, trascina e rilascia Esegui attività SQL al Flusso di controllo finestra e rinominala come Popola dati dai server . Vedi l'immagine seguente:

Fare doppio clic su Esegui attività SQL (Popolare i dati dal server). L'Esegui Editor attività SQL si apre la finestra di dialogo per configurare la connessione SQL. Vedi l'immagine seguente:

Nella Connessione archiviato, seleziona OLEDB stringa di connessione e nell'istruzione SQL campo, fornire la seguente query:

USE monitoringdashboard 
go 
EXEC Generate_database_information

Fare clic su OK per chiudere la finestra di dialogo.

Sul flusso di controllo schermo, trascina e rilascia Attività flusso di dati da SSIS Toolbox e rinominala come Genera rapporto. Vedi l'immagine seguente:

Fare doppio clic per aprire il Flusso di dati finestra.

Come accennato in precedenza, Generate_Database_Information La procedura inserisce l'output dei database server nelle seguenti tabelle:

1. Database_Object_Estate
2. Database_Estate
3. Lista_Lavori_SQL

Ho creato un file Excel con tre fogli di lavoro. Le tabelle seguenti mostrano la mappatura delle tabelle SQL e del foglio di lavoro di Excel.

Nel flusso di dati finestra, trascina e rilascia tre sorgenti ADO.Net e tre destinazioni Excel. Vedi l'immagine seguente:

Fare doppio clic su Riepilogo oggetto y (Sorgente ADO.NET) in Sorgente ADO.NET Editor.

1. Seleziona TTI412-VM\SQL2017MonitoringDashboard dal Gestione connessioni ADO.NET casella a discesa.
2. Seleziona Tabella o Visualizza dalla Modalità di accesso ai dati casella a discesa.
3. Seleziona Database_Object_Estate da Nome della tabella o della vista casella a discesa.

Fare doppio clic su Informazioni database (Sorgente ADO.NET) in Editor Sorgente ADO.NET .

1. Seleziona "TTI412-VM\SQL2017MonitoringDashboard ” dal Gestione connessioni ADO.NET casella a discesa.
2. Seleziona Tabella o Visualizza dalla Modalità di accesso ai dati casella a discesa.
3. Seleziona “Database_Estate ” dal Nome della tabella o della vista casella a discesa.

Fare doppio clic su Lavori SQL (Sorgente ADO.NET) in Editor Sorgente ADO.NET .

1. Seleziona TTI412-VM\SQL2017MonitoringDashboard nella gestione connessione ADO.NET.
2. Seleziona Tabella o Visualizza dalla Modalità di accesso ai dati casella a discesa.
3. Seleziona SQL_Job_List nel Nome della tabella o della vista casella a discesa.

Ora trascina e rilascia tre destinazioni Excel da SSIS Toolbox. Vedi l'immagine seguente:

Una volta copiate le destinazioni, trascinare la freccia blu sotto l'origine ADO.Net e rilasciarla sulla destinazione Excel. Fai lo stesso per tutti. Vedi l'immagine seguente:

Fare doppio clic su Riepilogo oggetto Excel (Sorgente ADO.NET) nell' Editor di destinazione di Excel .

1. Seleziona Excel Connection Manager da Gestione connessioni Excel casella a discesa.
2. Seleziona Tabilita o Visualizza dalla Modalità di accesso ai dati casella a discesa.
3. Seleziona Oggetto Summery$ dal Nome del foglio excel casella a discesa.

Come accennato, i nomi delle colonne della tabella SQL e delle colonne di Excel sono gli stessi, quindi la mappatura verrà eseguita automaticamente. Fai clic su Mappatura per mappare le colonne. Vedi l'immagine seguente:

Fare doppio clic su Informazioni sul database di Excel (Destinazione di Excel) in Editor di destinazione di Excel .

1. Seleziona Excel Connection Manager da Gestione connessioni Excel casella a discesa.
2. Seleziona Tabilita o Visualizza dalla Modalità di accesso ai dati casella a discesa.
3. Seleziona Informazioni database$ dal Nome del foglio excel casella a discesa.

Come accennato, i nomi delle colonne della tabella SQL e delle colonne di Excel sono gli stessi, quindi la mappatura verrà eseguita automaticamente. Fai clic su Mappatura per mappare le colonne. Vedi l'immagine seguente:

Fare doppio clic su Excel SQL Jobs (Destinazione di Excel) in Editor di destinazione di Excel .

1. Seleziona Excel Connection Manager da Gestione connessioni Excel casella a discesa.
2. Seleziona Tabilita o Visualizza dalla Modalità di accesso ai dati casella a discesa.
3. Seleziona "SQL Jobs$ dal Nome del foglio Excel casella a discesa.

Come accennato, i nomi delle colonne della tabella SQL e delle colonne di Excel sono gli stessi, quindi la mappatura verrà eseguita automaticamente. Fai clic su Mappatura per mappare le colonne. Vedi l'immagine seguente:

Crea un processo SQL per inviare via email il report del database

Una volta creato il pacchetto, crea un processo SQL per eseguire le seguenti attività:

1. Esegui il pacchetto SSIS per popolare i dati da tutti i server.
2. Invia il rapporto del database via email al team richiesto.

In SQL Job, dobbiamo creare due passaggi. Il primo passaggio eseguirà il pacchetto SSIS e il secondo passaggio eseguirà la procedura per inviare un'e-mail.

Per creare un processo SQL, apri SSMS>> SQL Server Agent>> Fare clic con il pulsante destro del mouse su Nuovo processo SQL .

Om il Nuovo lavoro procedura guidata, seleziona il Passaggio opzione e fai clic su Nessuno w. Nel nuovo passaggio di lavoro finestra di dialogo, nel passaggio nome casella di testo, fornire il nome desiderato, selezionare Pacchetto di servizi di integrazione di SQL Server dal Tipo casella a discesa. Fornisci una posizione del pacchetto SSIS nel Testo del pacchetto scatola. Vedi l'immagine seguente:

Fai clic su OK per chiudere Nuovo passaggio di lavoro .

Creare un altro passaggio di lavoro che eseguirà una procedura memorizzata per inviare il rapporto tramite e-mail. Utilizza una procedura di sistema per inviare un'e-mail. Il pacchetto SSIS copia le informazioni del database in una posizione specifica, quindi fornisce il percorso completo del file excel nel parametro @file_attachments di sp_send_dbmail procedura memorizzata.

Per creare la stored procedure, eseguire il codice seguente in DBATools database del server centrale:

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 fare un passo. 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 finestra. 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.