# Aggregating and Pivoting Data in Microsoft SQL Server 2008 T-SQL

- By Itzik Ben-Gan, Steve Kass, Lubor Kollar, Dejan Sarka
- 3/25/2009

## Histograms

Histograms are powerful analytical tools that express the distribution of items. For example, suppose you need to figure out from the order information in the Sales.OrderValues view how many small, medium, and large orders you have, based on the order values. In other words, you need a histogram with three steps. The extreme values (the minimum and maximum values) are what defines values as small, medium, or large. Suppose for the sake of simplicity that the minimum order value is 10 and the maximum is 40. Take the difference between the two extremes (*40 – 10 = 30*) and divide it by the number of steps (3) to get the step size. In this case, it’s 30 divided by 3, which is 10. So the boundaries of step 1 (small) would be 10 and 20; for step 2 (medium), they would be 20 and 30; and for step 3 (large), they would be 30 and 40.

To generalize this, let *mn = MIN(val)* and *mx = MAX(val)* and let *stepsize = (mx – mn) / @numsteps*. Given a step number *n*, the lower bound of the step (*lb*) is *mn + (n – 1) * stepsize* and the higher bound (*hb*) is *mn + n * stepsize*. Something is tricky here. What predicate do you use to bracket the elements that belong in a specific step? You can’t use *val BETWEEN lb and hb* because a value that is equal to *hb* appears in this step and also in the next step, where it equals the lower bound. Remember that the same calculation yielded the higher bound of one step and the lower bound of the next step. One approach to deal with this problem is to increase each of the lower bounds besides the first by one so that they exceed the previous step’s higher bounds. With integers, this is a fine solution, but with another data type (such as NUMERIC in our case) it doesn’t work because there are potential values between adjacent steps but not within either one—between the cracks, so to speak.

What I like to do to solve the problem is keep the same value in both bounds, and instead of using BETWEEN, I use *val >= lb* and *val < hb*. This technique has its own issues, but I find it easier to deal with than the previous technique. The issue here is that the item with the highest quantity (40, in our simplified example) is left out of the histogram. To solve this, I add a very small number to the maximum value before calculating the step size: *stepsize = ((1E0*mx + 0.0000000001) – mn) / @numsteps*. This technique allows the item with the highest value to be included, and the effect on the histogram is otherwise negligible. I multiplied *mx* by the float value *1E0* to protect against the loss of the upper data point when *val* is typed as MONEY or SMALLMONEY.

So you need the following ingredients to generate the lower and higher bounds of the histogram’s steps: *@numsteps* (given as input), step number (the *n* column from the Nums auxiliary table), *mn*, and *stepsize*, which I described earlier.

Here’s the T-SQL code required to produce the step number, lower bound, and higher bound for each step of the histogram:

USE InsideTSQL2008; DECLARE @numsteps AS INT; SET @numsteps = 3; SELECT n AS step, mn + (n - 1) * stepsize AS lb, mn + n * stepsize AS hb FROM dbo.Nums CROSS JOIN (SELECT MIN(val) AS mn, ((1E0*MAX(val) + 0.0000000001) - MIN(val)) / @numsteps AS stepsize FROM Sales.OrderValues) AS D WHERE n < = @numsteps;

This code generates the following output:

step lb hb ----------- ---------------------- ---------------------- 1 12.5 5470.83333333337 2 5470.83333333337 10929.1666666667 3 10929.1666666667 16387.5000000001

You might want to encapsulate this code in a user-defined function to simplify the queries that return the actual histograms, like so:

IF OBJECT_ID('dbo.HistSteps') IS NOT NULL DROP FUNCTION dbo.HistSteps; GO CREATE FUNCTION dbo.HistSteps(@numsteps AS INT) RETURNS TABLE AS RETURN SELECT n AS step, mn + (n - 1) * stepsize AS lb, mn + n * stepsize AS hb FROM dbo.Nums CROSS JOIN (SELECT MIN(val) AS mn, ((1E0*MAX(val) + 0.0000000001) - MIN(val)) / @numsteps AS stepsize FROM Sales.OrderValues) AS D WHERE n < = @numsteps; GO

To test the function, run the following query, which will give you a three-row histogram steps table:

SELECT * FROM dbo.HistSteps(3) AS S;

To return the actual histogram, simply join the steps table and the OrderValues view on the predicate I described earlier (*val >= lb AND val < hb*), group the data by step number, and return the step number and row count:

SELECT step, COUNT(*) AS numorders FROM dbo.HistSteps(3) AS S JOIN Sales.OrderValues AS O ON val >= lb AND val < hb GROUP BY step;

This query generates the following histogram:

step numorders ----------- ----------- 1 803 2 21 3 6

You can see that there are 803 small orders, 21 medium orders, and 6 large order. To return a histogram with 10 steps, simply provide 10 as the input to the *HistSteps* function:

SELECT step, COUNT(*) AS numorders FROM dbo.HistSteps(10) AS S JOIN Sales.OrderValues AS O ON val >= lb AND val < hb GROUP BY step;

This query generates the following output:

step numorders ----------- ----------- 1 578 2 172 3 46 4 14 5 3 6 6 7 8 8 1 10 2

Note that because you’re using an inner join, empty steps are not returned like in the case of step 9. To return empty steps also, you can use the following outer join query:

SELECT step, COUNT(val) AS numorders FROM dbo.HistSteps(10) AS S LEFT OUTER JOIN Sales.OrderValues AS O ON val >= lb AND val < hb GROUP BY step;

As you can see in the output of this query, empty steps are included this time:

step numorders ----------- ----------- 1 578 2 172 3 46 4 14 5 3 6 6 7 8 8 1 9 0 10 2

There’s another alternative to taking care of the issue with the step boundaries and the predicate used to identify a match. You can simply check whether the step number is 1, in which case you subtract 1 from the lower bound. Then, in the query generating the actual histogram, you use the predicate *val > lb AND val <= hb*.

Another approach is to check whether the step is the last, and if it is, add 1 to the higher bound. Then use the predicate *val >= lb AND val < hb*.

Here’s the revised function implementing the latter approach:

ALTER FUNCTION dbo.HistSteps(@numsteps AS INT) RETURNS TABLE AS RETURN SELECT n AS step, mn + (n - 1) * stepsize AS lb, mn + n * stepsize + CASE WHEN n = @numsteps THEN 1 ELSE 0 END AS hb FROM dbo.Nums CROSS JOIN (SELECT MIN(val) AS mn, (1E0*MAX(val) - MIN(val)) / @numsteps AS stepsize FROM Sales.OrderValues) AS D WHERE n < = @numsteps; GO

And the following query generates the actual histogram:

SELECT step, COUNT(val) AS numorders FROM dbo.HistSteps(3) AS S LEFT OUTER JOIN Sales.OrderValues AS O ON val >= lb AND val < hb GROUP BY step;