The folks from Pragmatic Works were back in So. Fla. about three weeks ago, this time with a workshop based in Analysis Services 2008, after the positive experience with their previous session, I could not miss this one.

To sum it up, again, I was not disappointed. This was a two-day class and the instructor was Devin (Brian’s brother).

The good thing about these workshops is that even though they use Microsoft’s sample database AdventureWorks, Pragmatic Works always sprinkle you with real-world examples as realistic as possible if only to put the matter at hand in perspective of how it applies to scenarios we come across at work.

For an introductory class it was well worth the time and money spent, no regrets . I wish they had shown an example of building cubes from the ground up, starting with the definition of the Dimensions, instead of using the wizard but I guess that could be considered advanced stuff. They did go into Data Mining with an excellent explanation of basic concepts, which at this level was a nice bonus.

Plus, another shirt, another book, for what I heard from other participants in the workshop, the anticipation from the audience now is for an SSRS class.

Here is a fairly detailed description of the request coming from management:

1 – Gather a list of new records from the Customers table and save it to a flat file on a local disk nightly
2 – Generate a fixed width ASCI file with the following structure:
Attribute (Field length)
- Customer Number (16)
- Customer Name (128)
- Address1 (128)
- Address2 (128)
- City (64)
- State (2)
- Zip (10)
- Company Id (16)

3 – Fill shorter values with spaces so all columns stay aligned in the flat file
4 – Segregate the datasets by accounting company and put them in separate text files
5 – Generate a file name with the following scheme companyname_yyyymmdd.txt

The following is a step-by-step guide of the process implemented using Integration Services 2008 to fulfill the requirements

I – Create a table with CHAR data type columns

There are two tables involved in this process
a – CUSTOMER_EXPORT – Is the list of companies to process since management does not want to include all companies in this process, the stored procedure reads from this table and performs the extract/save for the records marked export_ = 1 (True)

The Customer Export table where accounting company databases are flagged for processing

b – CUSTOMERS is the complete list of customers from all the companies, every single column on every single row in this table needs to have a value (a space for empty fields, empty fields cannot be NULL) so that in the query the empty fields become a string of spaces

The structure of the Customer table

The Customer table in design view, all relevant fields are CHAR type and do not allow nulls

The Customer table data

The Customer table data, the field 'updated_on' is used to identify (new) records to be exported

2 – Build a package to extract the data and save it to disk
3 – Write a stored procedure to drive the SSIS package
4 – Add an SQL Server job that executes the stored procedure every night

Create a new SSIS package and set its security to “Encrypt Sensitive with password”

2 – Create 3 package variables and set their data type to STRING
a – flat_file, company_id, export_date

The three package variables that will be passed as arguments when executing the package from the stored procedure

The OLE DB connection using SQL Server authentication and the option to save the password, passwords are encrypted everywhere they are used.

The flat file connection using an expression for the connection string so the destination file name can be generated dynamically

SELECT
[customer_number] +
[name] +
[address1] +
[address2] +
[city] +
[state] +
[zip] +
[company_id] AS customer_record
FROM customers WHERE company_id = ? AND updated_on = ?

b – Set the input parameters to the variables company_id and export_date

[insert picture here]

c – Add a Flat File Destination and connect the output of the OLE DB data source to it

[insert picture here]

5 – Create a stored procedure to call (execute) or “run” the package
a – Make sure you encrypt the store procedure so that the package password is not visible
b – Keep the package password in a safe place, you will need it to open the package in BIDS

CREATE PROCEDURE [dbo].[usp_client_file]
WITH ENCRYPTION
AS
DECLARE @year_ CHAR(4)
DECLARE @month_ CHAR(2)
DECLARE @day_ CHAR(2)
DECLARE @export_date VARCHAR(128)
DECLARE @insert_command VARCHAR(2048)
DECLARE @company VARCHAR(128)
DECLARE @company_id VARCHAR(16)
DECLARE @flat_file VARCHAR(128)
DECLARE @dtexec_ VARCHAR(2048)
SET @year_ = CAST(DATEPART(year, getdate()) AS CHAR(4))
IF DATEPART(MONTH, GETDATE()) < 10 SET @month_ = ’0′ + CAST(DATEPART(MONTH, GETDATE()) AS CHAR(2)) ELSE SET @month_ = CAST(DATEPART(MONTH, GETDATE()) AS CHAR(2))
IF DATEPART(DAY, GETDATE()) < 10 SET @day_ = ’0′ + CAST(DATEPART(DAY, GETDATE()) AS CHAR(2)) ELSE SET @day_ = CAST(DATEPART(DAY, GETDATE()) AS CHAR(2))
SET @export_date = @year_ + @month_ + @day_
DECLARE db_cursor CURSOR FOR
SELECT name FROM [dbo].[customer_export] WHERE export_ = 1
OPEN db_cursor
FETCH NEXT FROM db_cursor INTO @company
WHILE @@FETCH_STATUS = 0
BEGIN
SET @company_id = (SELECT company_id FROM customer_export WHERE name = @company)
SET @dtexec_ = ‘dtexec /FILE c:\ssis\packages\clients_file.dtsx /DE “y0ur_p@ssw0rd” /SET \Package.Variables[User::flat_file].Value;”\”c:\exports\’ + @company + ‘_’ + @export_date + ‘.txt”" /SET \Package.Variables[User::export_date].Value;’ + @export_date + ‘ /SET \Package.Variables[User::company_id].Value;’ + @company_id + ”
EXEC xp_cmdshell @dtexec_
FETCH NEXT FROM db_cursor INTO @company
END
CLOSE db_cursor
DEALLOCATE db_cursor

And that takes care of the assignment, if you schedule this stored procedure to run once a day, the package will extract a list of new customers and save it to local storage using a unique file name driven by a timestamp

This post is a demonstration of how to use the SSIS 2008 Foreach Loop Container to execute a routine against a dataset one record at a time. I have chosen the DBA task of fixing orphaned users to illustrate this technique.

The challenge: We need to restore several databases that are ready for testing from our Development environment into our UAT instance, as this databases are restored the login/user “links” are lost and we end up with orphaned users, if we restore a dozen databases and our testing group consist of another dozen users the task of manually fixing them becomes a little daunting.

The solution: Use an SSIS package to automate the process of executing the system stored procedure SP_CHANGE_USERS_LOGIN to each an every user on each and every database

Fig. 1 – A list of “fake” databases and users in my Lab’s UAT system, the target of the multiple database restores

List of databases and logins

Fig. 2 – The user ABROWN exists “Without Login” after the restore

Database user without login

Fig. 3 – A high level view of the package using the Foreach Loop Container

High level view of the package with the Foreach Loop Container

1 – Add an OLE DB connection to the package

The OLE DB connection

2 – Add a package level variable and set its type Object, for this example I called this variable “db_login_ado”

3 – Add an Execute SQL Task (code below) and set the ResultSet property to “Full result set”
SELECT D.name AS database_, L.name AS login_
FROM sys.databases D, sys.server_principals L
WHERE D.database_id > 4 AND (L.type_desc = ‘sql_login’)
ORDER BY D.name

Execute SQL Task

3a – Add a result set, call it 0 (zero) and assign it to the db_login_ado variable

Result set 0 of the Execute SQL Task

4 – Add a Foreach Loop Container and set it’s collection to “foreach ado enumerator”

4a – In the Collection area of the this container set the “ADO object source variable” property to the variable coming from the Execute SQL Task

The Foreach Loop Container

5 – Add two String variables, one for the databases and the other one for the logins

6 – In the Variable Mappings area of the container add two entries one for each one of the string variables you just added in the previous step. Make sure your “database” variable, which the first column of the dataset is set to Index 0 and the “logins” variable, which the second column in the dataset is set to index 1

Variable Mappins of the Foreach Loop Container

7 – Add an execute sql task to the foreach container
DECLARE @dbname VARCHAR(128)
DECLARE @dbuser VARCHAR(128)
DECLARE @commandchangeuser VARCHAR(1024)
SET @dbname = ?
SET @dbuser = ?
SET @commandchangeuser = ‘USE ‘ + @dbname + ‘; IF EXISTS (SELECT name FROM sysusers WHERE name = ”’ + @dbuser + ”’) EXEC sp_change_users_login ”auto_fix”, ‘ + @dbuser + ”
EXECUTE(@commandchangeuser)

Execute SQL Task inside the Foreach Loop Container

7a – Map the input parameters to the string variables set in the Foreach Loop Container, parameter names must be 0 and 1, the parameter size is the length of the VARCHAR data type

Parameter Mappings of the Execute SQL Task

A successful run of the package

The execution of the pacakage completed successfuly

The user ABROWN is now linked to the login ABROWN after running the package

User status after the package ran

Bringing the data captured by a server-side trace into a table is a very convenient way to review the trace results when monitoring and analyzing database activity. One thing I immediately thought of when implementing this kind of solution was to do it periodically and incrementally.

SQL Server 2008 does not come with built-in functionality to append data to an existing trace file or to overwrite it and start fresh using the same file name.

One possible arrangement to achieve this has been explained in other blogs and requires the use of several trace files which is SQL Server’s default behavior. Since this technique is not without flaws and I can afford to stop the data capturing process for a minute while I import the data and refresh the trace file I did come up with the following script which lets me simulate the “refreshing” feature not available in SQL Server 2008.

Run this command first to build the table that is going to store the trace data before you put the script in a store procedure or an SQL Server Agent job

SELECT *
INTO   db_name.schema_name.table_name
FROM   Fn_trace_gettable(‘d:\trace\my_trace_file.trc’, DEFAULT) trace 

Once you have the table in place you can use the script below to keep adding data to it as frequently as necessary or possible

DECLARE @trace_id INT
-- Use the path to your trace file to get the Id of the trace you are working with
SET @trace_id = (SELECT id
                 FROM   sys.traces
                 WHERE  [path] = ‘d:\trace\my_trace_file.trc’)
-- If you get something back the trace is running
IF @trace_id IS NOT NULL
  BEGIN
      -- Stop the trace so it dumps the data into the file
      EXEC Sp_trace_setstatus
        @traceid = @trace_id,
        @status = 0
      -- Import the data from the trace file into a table
      INSERT INTO db_name.schema_name.table_name
      SELECT *
      FROM   Fn_trace_gettable(‘d:\trace\my_trace_file.trc’, DEFAULT) trace
      EXEC Sp_trace_setstatus
        @traceid = @trace_id,
        @status = 2
      -- Delete the trace file
      EXEC Xp_cmdshell ‘erase d:\trace\my_trace_file.trc’
  END 

Now you are ready to kick start the trace again using the same (fixed) file name you used before, probably another step in an SQL Server Agent job.

A continuous learning effort is just one of a few constants across the different areas of the IT field. Thru the years I have, for the most part, satisfied the need for training thru self-study, with the occasional exception of an employer-sponsored week of Oracle 10 or SQL Server 2005 administration at an authorized training facility, and my personal experience is that not even official training at a local college matches the return on investment against doing the study yourself.

Problem:
Like any manual process, adding users to databases and setting their permissions on more than a few databases is a tedious and error-prone endeavor. By creating a couple of “admin” stored procedures, a DBA can automate this process to the point of being able to execute this task in one fell swoop, at the query editor by typing a few words just once.

If you care for documentation [I do], SQL Server Extended Properties are very convenient when it comes to adding tags, or labels to objects. I particularly find very useful to mark databases with notes that describe their purpose or their level of security sensitivity, etc…

Once you have a standard for these documentation tags and you keep them updated they can be a huge helper for performing database administration tasks very effectively.

Here is a list of the components I’m using to build this solution. I’m keeping all these administrative objects in the (I hope this name is descriptive enough) UTILTY_ADMIN user database

1 – The table to keep a list of the databases that are currently online and have a some kind of Extended Property

USE utility_admin
CREATE TABLE extendedproperties
  (
     dbname   VARCHAR(255),
     ep_name  VARCHAR(128),
     ep_value VARCHAR(128)
  ) 

2 – The stored procedure that does the brunt of the work, querying the Extended Properties of each database and storing them in the UTILITY_ADMIN.dbo.ExtendedProperties table

USE utility_admin
GO
CREATE PROCEDURE Getextendedproperties @DatabaseName VARCHAR(255) = NULL
AS
  IF @DatabaseName IS NULL
    SET @DatabaseName = Db_name()
  DECLARE @SQLText NVARCHAR(2000)
  IF Object_id(N’tempdb.dbo.##temp_ExtendedProperties’) IS NOT NULL
    DROP TABLE ##temp_extendedproperties
  CREATE TABLE ##temp_extendedproperties
    (
       ep_name  VARCHAR(128),
       ep_value VARCHAR(128)
    )
  SET @SQLText =
‘INSERT INTO ##temp_ExtendedProperties SELECT CAST(name AS VARCHAR(128)), CAST(value AS VARCHAR(128)) FROM ’
+ @databasename +
‘.sys.fn_listextendedproperty(default, default, default, default, default, default, default)’
  -- That is 7 defaults
  EXECUTE(@SQLText) 

3 – An SQL Server Agent job that runs every hour so that the list of databases with extended properties stays up to date

TRUNCATE TABLE utility_admin.dbo.extendedproperties
EXEC MASTER.sys.Sp_msforeachdb
‘INSERT INTO utility_admin.dbo.ExtendedProperties EXEC utility_admin.dbo.GetExtendedProperties ?’ 

4 – UTILTIY_ADMIN.dbo.dbaManageUserRole – This is the stored procedure you are going to execute to actually add the user and set his/her permissions. It requires three parameters, the name of the user, the name of the extended property and the value of the extended property. I have hardwired the db_datareader role into this procedure but with a little bit of imagination you could also add the role as a parameter and make it even more flexible.

CREATE PROCEDURE Dbamanageuserrole @user     VARCHAR(64),
                                   @ep_name  VARCHAR(128),
                                   @ep_value VARCHAR(128)
AS
  DECLARE @dbname VARCHAR(128)
  DECLARE @adduser VARCHAR(512)
  DECLARE @addrole VARCHAR(512)
  DECLARE dbcursor CURSOR FOR
    SELECT dbname
    FROM   utility_admin.dbo.extendedproperties
    WHERE  ep_name = @ep_name
           AND ep_value = @ep_value
  OPEN dbcursor
  FETCH NEXT FROM dbcursor INTO @dbname
  WHILE @@FETCH_STATUS = 0
    BEGIN
        SET @adduser = ‘USE ’ + @dbname + ‘; CREATE USER ’ + @user +
                       ‘ FOR LOGIN ’
                       +
                       @user
        SET @addrole = ‘USE ’ + @dbname +
                       ‘; EXEC sp_addrolemember N”db_datareader”, ’ + @user
        EXECUTE(@adduser)
        EXECUTE(@addrole)
        FETCH NEXT FROM dbcursor INTO @dbname
    END
  CLOSE dbcursor
  DEALLOCATE dbcursor 

Now we are ready to enjoy the rewards of our hard work time and time again. Here is the command I used to add the user ‘canela’ as a ‘db_datareader’ to all the databases I have tagged with ‘application_’ ‘reporting_’

EXEC Dbamanageuserrole
  canela,
  application_,
  reporting_ 

Here is a picture of one of my lab servers showing a long list of dummy databases on the left pane and a shorter result list of the ones with extended properties on the bottom right side.

Synopsis:

When you create an ASP .NET 4 website in Visual Studio 2010 and do not modify any of its default settings as you run or debug this website from the IDE it starts and uses a special web server called Cassini, it does not run in the full blown, professional grade Windows web server (IIS 7)

Microsoft had many reasons to ship this special web server and have it run by default when Visual Studio and Visual Web Developer start a debug session on a project, but I do see a couple of issues with this:

1st – In the real world applications use IIS 7 not Cassinni, so I want to run/debug/test in IIS 7 not Cassini

2nd – Cassini is only available while IDE is running, and it shuts down when you close Visual Studio. I want to be able to use the website and test it at any time, directly from any local browser or remotely from other workstations over the network, without having to keep a Visual Web Developer session open.

These two requirements seem very basic, I don’t feel comfortable testing a project that eventually will be deployed to production unless the site is proven to run stably on the web server that will be hosting it permanently, and I need the flexibility of an always up web server.

So, after a bit of research and some trial and error experimenting, I found the procedure listed below will satisfy this need.

1 – Create a file system folder (c:\websites\mysite
2 – Create a website in IIS 7 that points to the folder you created in step 1
3 – Create an ASP .NET 4.0 website project in Visual Studio 2010 and use the folder you created in step 1 as the target folder
4 – Save the project
5 – Modify the URL in Website Start…

From now on in order to run the website from the IDE in debug mode you need to open Visual Studio with the command “Run as Administrator”

Or use the menu Debug – Attach to Process

6 – Debug the project in Visual Studio 2010 or try to browse the site in a browser window

If you receive the error message “Unrecognized attribute ‘targetFramework’”, make sure the application pool for the website “mysite” in ISS 7 is set to support the 4.0 .NET Framework

Follow the next steps if you want to go a bit further and test the data access layer

1. Add a database connection to your project
2. Add a database control to the page Default.aspx
3. Save the project
4. Debug the project in Visual Studio 2010 or try to browse the site in a browser window

When I built the test for the data access layer on the 2nd environment [specs listed below] I ran into this problem:

‘Handler “PageHandlerFactory-Integrated” has a bad module “ManagePipelineHandler” in its module list’

To resolve it I ran the command
c:\windows\Microsoft.NET\Framework\v4.030319\aspnet_regiis.exe –i

There are some explanations about this issue on the internet and even more than one way (command) to resolve it. I know I installed SQL Server 2008 Service Pack 1 after the .NET framework and ASP .NET 4 so that could have been the problem but the command listed above took care of it in a couple of seconds.

This procedure applies to “WEBSITE” projects, if you created an ASP .NET “application” project, most of this work can be very easily done thru the menu.

Technologies used:

1st Environment
- Windows Server 2008 R2 Enterprise 64-bit
- SQL Server 2008 R2 Standard 64-bit
- Internet Information Service (IIS) 7
- Visual Studio Professional 2010

2nd environment
- Windows Server 2008 Standard 32-bit with Service Pack 2
- SQL Server 2008 Standard 32-bit with Service Pack 1
- Internet Information Services (IIS) 7
- Visual Web Developer Express 2010

Who can benefit from this post? – This post does not go into the details of how to build a solution to query Active Directory using SQL Server. Instead it presents a workaround for people that are already querying Active Directory using SQL Server and are hitting the 1000 records barrier imposed by ADSI.

As always, this is a short and sweet post so all the information needed to perform certain actions will not be included here. However the article should give you enough information to help you resolve the issue at hand fairly quickly.

Really QUICK-AND-DIRTY solution: If you have access to modify Active Directory settings, increase the value of MaxPageSize from its default of 1000 to something that suits your needs, BUT please read Avoid changing the MaxPageSize LDAP query policy to understand the possible consequences of this action, the author (unlike me) seems to know quite a bit about the topic.

For the rest of us – the ones that can only “view” Active Directory – read below.

The first time I had to work on a solution to query Active Directory using SQL Server I remember reading on the Internet a few posts talking about the 1000 records limit and at least one possible trick to bypass it. At the time it was not an issue for me, the AD implementation I was working with had less than 1000 users, so I didn’t pay attention to the specifics of the solution. I don’t know about you, but 99% percent of the time when I’m working on a project/task, there is barely enough time to get it out, let alone plan/build for “scalability”.

So here we are now with report consumers complaining about some user names missing from the “employee” list.

As I troubleshooted this issue, I noticed that there are a few user properties in AD that could break the dataset into chunks smaller than 1000 records, which I could then put together one at a time in a table and end up with the complete data set.

The property I choose to use was “whenCreated”, I could determine that if I added the filter “whenCreated < 20100101000000.0Z” to the WHERE clause of the query, Active Directory would return about 900 records. To get the rest of the data set (close to 300 records) I changed the query to whenCrated GREATER THAN 20100101000000.0Z

Here is a copy of the two complete queries:

INSERT INTO my_ad_users_list
SELECT givenname                  AS firstname,
       sn                         AS lastname,
       initials,
       displayname,
       samaccountname             AS ACCOUNT,
       telephonenumber,
       mobile,
       facsimiletelephonenumber   AS fax,
       pager,
       mail                       AS emailaddress,
       department,
       title,
       l                          AS city,
       postalcode,
       ipphone                    AS extension,
       physicaldeliveryofficename AS office,
       ‘my_domain’                AS domain,
       ‘regular’                  AS usertype
FROM   Openquery (adsi, ‘SELECT givenname, sn, initials, displayname, sAMAccountName, telephoneNumber,
 mobile, facsimileTelephoneNumber, pager, mail, department, title, l, PostalCode, ipPhone, physicalDeliveryOfficeName

  WHERE userAccountControl=512 AND objectCategory = ”Person” AND objectClass = ”user”
 AND whenCreated > ”20100101000000.0Z”’)
WHERE  givenname IS NOT NULL
       AND sn IS NOT NULL 

Tools used

-          SQL Server 2005

-          ADExplorer

There is a huge difference between numeric data types. Without going into the details of how much memory they use or any other technicalities that could take a whole chapter in a book, let’s just say that you can, on purpose or accidentally, use a larger than necessary numeric type For example Decimal, to store Integers, and your program will not crash and everything will “just work”.

But will it work efficiently? Could this be considered an optimized design? Not at all.

Consider this scenario

1 – You use an SSIS package to import data from Oracle into SQL Server and you tell the OLE DB Destination in the Data Flow Task to create new tables for you automatically
2 – You know the application logic and you know that certain fields will never hold a value greater than 1000. What you don’t know is that these fields have been stored in Oracle using the Number(15,0) data type and SSIS set them in the destination table as Numeric(15,0)
3 – You create a join between the two imported tables and start manipulating the data. As you run the update queries you notice that for certain logic using certain fields, updating a third table with about 20,000 records takes literally 3 seconds, while performing the same operation but using a different field takes close to 3 minutes. Obviously there is an enormous difference that at first look does not make any sense

As you start looking more deeply into the problem you notice that the query that runs very fast uses a column of the Integer data type, while the slow query uses a field set to Numeric(15,0).

Since you know that this is not the correct data type for the field you alter the table and change it to Integer. Now you run the two queries and they BOTH take 3 seconds.

Consider how this small (data type) lapse made a simple update operation run 60 times slower than it should have normally taken.

Lesson learned: “Trust but verify”. At least when performance matters, which is probably 99.99% of the time.

It sure is convenient to let SSIS create the table automatically for you. Having to manually create a table before bringing in the data could be very labor intensive, especially if the table has dozens of columns. Just go back and look at what SSIS did for you and make sure it is what you need.

Technologies used:
- Oracle 9 on Solaris 9
- SQL Server 2008 Standard on Windows Server 2008 Enterprise 64-bit
- T-SQL
- SSIS 2005
- Microsoft Office (Excel) 2010 Professional

A complete solution would include sending data from several servers into a central server, in this example I’m going to show you how to do it for one server. Also the final presentation of the data should use some form of reporting tool that could display this data in a portal for easy consumption.

Step 1 – Create a table to store the backup information that will be captured periodically

USE utility
GO
CREATE TABLE [dba].[backups](
[backup_log_id] [int] IDENTITY(1,1) NOT NULL,
[server_name] [nvarchar](64) NULL,
[database_name] [nvarchar](128) NULL,
[start_date] [datetime] NULL,
[finish_date] [datetime] NULL,
[expiration_date] [datetime] NULL,
[backup_type] [nvarchar](64) NULL,
[backup_size] [int] NULL,
[physical_device_name] [nvarchar](128) NULL,
[backupset_name] [nvarchar](128) NULL,
[user_name] [nvarchar](64) NULL,
[backup_log_date] [datetime] NULL,
CONSTRAINT [PK_backups] PRIMARY KEY CLUSTERED(
[backup_log_id] 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

Step 2 – Create the store procedure that will capture the data and save it to the backup information table

USE msdb
GO
CREATE PROCEDURE [dbo].[usp_backup_status]
AS
BEGIN
SET NOCOUNT ON;
DECLARE @backup_log_date DATETIME
SET @backup_log_date = (SELECT DATEADD(dd, DATEDIFF(dd, 0, GetDate()), 0))
INSERT INTO utility.dba.backups
SELECT RTRIM(CONVERT(CHAR(100), SERVERPROPERTY('Servername'))) AS Server,
a.name,
b.backup_start_date,
d.backup_finish_date,
b.expiration_date,
CASE b.type
WHEN 'D' THEN 'Database'
WHEN 'L' THEN 'Log'
WHEN 'I' THEN 'Differential database'
WHEN 'F' THEN 'File or filegroup'
WHEN 'G' THEN 'Differential file'
WHEN 'P' THEN 'Partial'
WHEN 'Q' THEN 'Differential partial'
WHEN NULL THEN 'Null'
END AS backup_type,
b.backup_size / 1024000 AS backup_size,
c.physical_device_name,
b.name AS backupset_name,
b.user_name,
@backup_log_date AS backup_log_date
FROM sys.databases AS a
LEFT OUTER JOIN
(SELECT
database_name,
MAX(backup_finish_date) AS backup_finish_date
FROM msdb.dbo.backupset
GROUP BY database_name
) AS d
ON a.name = d.database_name
LEFT OUTER JOIN msdb.dbo.backupset AS b
ON (a.name = b.database_name) AND (b.backup_finish_date = d.backup_finish_date)
LEFT OUTER JOIN msdb.dbo.backupmediafamily AS c
ON b.media_set_id = c.media_set_id
ORDER BY a.name
END

Step 3 – Create a job to run the stored procedure as frequently as needed

Step 4 – Query the “backups” table to see information about today’s backups

SELECT
[server_name],
[database_name],
[start_date],
[finish_date],
[expiration_date],
[backup_type],
[backup_size],
[physical_device_name],
[backupset_name],
[user_name],
[backup_log_date]
FROM [utility].[dba].[backups]
WHERE [backup_log_date] = (SELECT DATEADD(dd, DATEDIFF(dd, 0, GetDate()), 0))