Question

We’ve got a query that is taking a very long time to complete with a large dataset. I think I’ve tracked it down to a table-value function in the SQL server.

The query is designed to return the difference in printing usage between two dates. So if a printer had usage of 100 at date x and 200 at date y a row needs to be returned which reflects that it has had a usage change of 100.

These readings are taken periodically (but not every day) and stored in a table called MeterReadings. The code for the table-value function is below. This is then called from another SQL query which joins the returned table on a devices table with an inner join to get extra device information.

Any advise as to how to optimise the below would be appreciated.

ALTER FUNCTION [dbo].[DeviceUsage]
-- Add the parameters for the stored procedure here
( @StartDate DateTime , @EndDate DateTime )
RETURNS table
AS
RETURN
(

SELECT      MAX(dbo.MeterReadings.ScanDateTime) AS MX,
        MAX(dbo.MeterReadings.DeviceTotal - reading.DeviceTotal) AS TotalDiff, 
        MAX(dbo.MeterReadings.TotalCopy - reading.TotalCopy) AS CopyDiff,
        MAX(dbo.MeterReadings.TotalPrint - reading.TotalPrint) AS PrintDiff,
        MAX(dbo.MeterReadings.TotalScan - reading.TotalScan) AS ScanDiff,
        MAX(dbo.MeterReadings.TotalFax - reading.TotalFax) AS FaxDiff,
        MAX(dbo.MeterReadings.TotalMono - reading.TotalMono) AS MonoDiff,
        MAX(dbo.MeterReadings.TotalColour - reading.TotalColour) AS ColourDiff, 
        MIN(reading.ScanDateTime) AS MN, dbo.MeterReadings.DeviceID

FROM        dbo.MeterReadings INNER JOIN (SELECT * FROM dbo.MeterReadings WHERE     
        (dbo.MeterReadings.ScanDateTime > @StartDate) AND 
        (dbo.MeterReadings.ScanDateTime < @EndDate) ) 
        AS reading ON dbo.MeterReadings.DeviceID = reading.DeviceID

WHERE       (dbo.MeterReadings.ScanDateTime > @StartDate) AND (dbo.MeterReadings.ScanDateTime < @EndDate)

GROUP BY    dbo.MeterReadings.DeviceID);

Answer 1

On the assumption that a value can only ever increase over time, it can certainly be simplified.

SELECT
  DeviceID,
  MIN(ScanDateTime)                      AS MN,
  MAX(ScanDateTime)                      AS MX,
  MAX(DeviceTotal ) - MIN(DeviceTotal)   AS TotalDiff,
  MAX(TotalCopy   ) - MIN(TotalCopy  )   AS CopyDiff,
  MAX(TotalPrint  ) - MIN(TotalPrint )   AS PrintDiff,
  MAX(TotalScan   ) - MIN(TotalScan  )   AS ScanDiff,
  MAX(TotalFax    ) - MIN(TotalFax   )   AS FaxDiff,
  MAX(TotalMono   ) - MIN(TotalMono  )   AS MonoDiff,
  MAX(TotalColour ) - MIN(TotalColour)   AS ColourDiff
FROM
  dbo.MeterReadings
WHERE
      ScanDateTime > @StartDate
  AND ScanDateTime < @EndDate
GROUP BY
  DeviceID

This assumes that if you have reading on dates 1, 3, 5, 7, 9 and you want to report on 2 -> 8 then you want reading 7 – reading 3. I would have thought you wanted reading 7 – reading 1?

The above query should be fine for relatively small ranges. If you have Huge ranges of time, the MAX() - MIN() will be operating on large numbers of rows. This can then possibly be improved even further with the following (with correlated sub-queries to lookup just the two rows that you want).

As a side benefit, this also works even if the values can go down as well as up.

(I assume the existance of a Device table for a simpler query and faster performance.)

SELECT
  Device.DeviceID,
  start.ScanDateTime                      AS MN,
  finish.ScanDateTime                     AS MX,
  finish.DeviceTotal - start.DeviceTotal  AS TotalDiff,
  finish.TotalCopy   - start.TotalCopy    AS CopyDiff,
  finish.TotalPrint  - start.TotalPrint   AS PrintDiff,
  finish.TotalScan   - start.TotalScan    AS ScanDiff,
  finish.TotalFax    - start.TotalFax     AS FaxDiff,
  finish.TotalMono   - start.TotalMono    AS MonoDiff,
  finish.TotalColour - start.TotalColour  AS ColourDiff
FROM
  dbo.Device                 AS device
INNER JOIN
  dbo.MeterReadings          AS start
    ON  start.DeviceID = device.DeviceID
    AND start.ScanDateTime = (SELECT MIN(ScanDateTime)
                                FROM dbo.MeterReadings
                               WHERE DeviceID = device.DeviceID
                                 AND ScanDateTime > @startDate
                                 AND ScanDateTime < @endDate)
INNER JOIN
  dbo.MeterReadings          AS finish
    ON  finish.DeviceID     = device.DeviceID
    AND finish.ScanDateTime = (SELECT MAX(ScanDateTime)
                                FROM dbo.MeterReadings
                               WHERE DeviceID = device.DeviceID
                                 AND ScanDateTime > @startDate
                                 AND ScanDateTime < @endDate)

This can also be modified to pick up the start as being the first date on or before @startDate, if required.

EDIT: Modification to pick the start reading as being for the first date on or before @startDate.

SELECT
  Device.DeviceID,
  start.ScanDateTime                                                AS MN,
  finish.ScanDateTime                                               AS MX,
  COALESCE(finish.DeviceTotal, 0) - COALESCE(start.DeviceTotal, 0)  AS TotalDiff,
  COALESCE(finish.TotalCopy  , 0) - COALESCE(start.TotalCopy  , 0)  AS CopyDiff,
  COALESCE(finish.TotalPrint , 0) - COALESCE(start.TotalPrint , 0)  AS PrintDiff,
  COALESCE(finish.TotalScan  , 0) - COALESCE(start.TotalScan  , 0)  AS ScanDiff,
  COALESCE(finish.TotalFax   , 0) - COALESCE(start.TotalFax   , 0)  AS FaxDiff,
  COALESCE(finish.TotalMono  , 0) - COALESCE(start.TotalMono  , 0)  AS MonoDiff,
  COALESCE(finish.TotalColour, 0) - COALESCE(start.TotalColour, 0)  AS ColourDiff
FROM
  dbo.Device                 AS device
LEFT JOIN
  dbo.MeterReadings          AS start
    ON  start.DeviceID = device.DeviceID
    AND start.ScanDateTime = (SELECT MAX(ScanDateTime)
                                FROM dbo.MeterReadings
                               WHERE DeviceID = device.DeviceID
                                 AND ScanDateTime < @startDate)
LEFT JOIN
  dbo.MeterReadings          AS finish
    ON  finish.DeviceID     = device.DeviceID
    AND finish.ScanDateTime = (SELECT MAX(ScanDateTime)
                                FROM dbo.MeterReadings
                               WHERE DeviceID = device.DeviceID
                                 AND ScanDateTime < @endDate)