SQL Saturday #486 Richmond – A Window Into Your Data

 

Thanks for attending my session on window functions in TSQL. I hope you learned something you can take back and use in your projects or at your work. You will find an link to the session and code I used below. If you have any questions about the session post them in comments and I will try to get you the answers.

Questions

1. Can an OVER clause be used in the WHERE clause?
   • No. The OVER clause can only be used in SELECT and ORDER BY clauses.
2. Some follow up on ROWS and RANGE with context to CURRENT ROW.
   • We had a lot of discussion around this. In our examples below, RANGE aggregated all the data that fit into the ORDER BY clause. ROWS only referenced the row it was in. So, RANGE looks at everything that meets the criteria established by the PARTITION BY and ORDER BY clauses. ROWS is bound to the physical row.
   • Code examples:

     • OVER (PARTITION BY CustomerName ORDER BY OrderDate RANGE CURRENT ROW)

       • Summed two rows of data for the customer with the date. Both rows had the same date.

     • OVER (PARTITION BY CustomerName ORDER BY OrderDate ROWS CURRENT ROW)

       • Each row only contained the data for the row it was in.

Slides, Code, and Follow Up Posts

The presentation can be found here: A Window into Your Data

The code was put into a Word document that you can get here: TSQL Window Function Code

This session is also backed by an existing blog series I have written.

T-SQL Window Functions – Part 1- The OVER() Clause

T-SQL Window Functions – Part 2- Ranking Functions

T-SQL Window Functions – Part 3: Aggregate Functions

T-SQL Window Functions – Part 4- Analytic Functions

Microsoft Resources:

• OVER Clause: http://msdn.microsoft.com/en-us/library/ms189461(v=SQL.110).aspx
• Analytic Functions: http://msdn.microsoft.com/en-us/library/hh213234(v=sql.110).aspx

SQL Saturday #437–Boston BI Edition 2015–You Can Still Analyze Data with T-SQL

Thanks for attending my session on analyzing data with TSQL. I hope you learned something you can take back and use in your projects or at your work. You will find an link to the session and code I used below. If you have any questions about the session post them in comments and I will try to get you the answers.

The presentation can be found here: Analyzing with TSQL

The code was put into a Word document that you can get here: Code to support the analysis with TSQL Sessions

This session is also backed by an existing blog series I have written.

T-SQL Window Functions – Part 1- The OVER() Clause

T-SQL Window Functions – Part 2- Ranking Functions

T-SQL Window Functions – Part 3: Aggregate Functions

T-SQL Window Functions – Part 4- Analytic Functions

Microsoft Resources:

• OVER Clause: http://msdn.microsoft.com/en-us/library/ms189461(v=SQL.110).aspx
• Analytic Functions: http://msdn.microsoft.com/en-us/library/hh213234(v=sql.110).aspx
• CUBE, ROLLUP, GROUPING SETS: : https://technet.microsoft.com/en-us/library/bb522495(v=sql.105).aspx

SQL Saturday #453–Minnesota 2015–A Window Into Your Data

Thanks for attending my session on window functions in TSQL. I hope you learned something you can take back and use in your projects or at your work. You will find an link to the session and code I used below. If you have any questions about the session post them in comments and I will try to get you the answers.

The presentation can be found here: A Window into Your Data

The code was put into a Word document that you can get here: TSQL Window Function Code

This session is also backed by an existing blog series I have written.

T-SQL Window Functions – Part 1- The OVER() Clause

T-SQL Window Functions – Part 2- Ranking Functions

T-SQL Window Functions – Part 3: Aggregate Functions

T-SQL Window Functions – Part 4- Analytic Functions

Microsoft Resources:

• OVER Clause: http://msdn.microsoft.com/en-us/library/ms189461(v=SQL.110).aspx
• Analytic Functions: http://msdn.microsoft.com/en-us/library/hh213234(v=sql.110).aspx
• CUBE, ROLLUP, GROUPING SETS: : https://technet.microsoft.com/en-us/library/bb522495(v=sql.105).aspx

T-SQL Window Functions – Part 4: Analytic Functions

This is a reprint with some revisions of a series I originally published on LessThanDot. You can find the links to the original blogs on my Series page.

In the final installment of my series on SQL window functions, we will explore using analytic functions. Analytic functions were introduced in SQL Server 2012 with the expansion of the OVER clause capabilities. Analytic functions fall in to two primary categories: values at a position and percentiles. Four of the functions, LAG, LEAD, FIRST_VALUE and LAST_VALUE find a row in the partition and returns the desired value from that row. CUME_DIST and PERCENT_RANK break the partition into percentiles and return a rank value for each row. PERCENTILE_CONT and PERCENTILE_DISC a value at the requested percentile in the function for each row. All of the functions and examples in this blog will only work with SQL Server 2012.
Once again, the following CTE will be used as the query in all examples throughout the post:

with CTEOrders as
(select cast(1 as int) as OrderID, cast(‘3/1/2012’ as date) as OrderDate, cast(10.00 as money) as OrderAmt, ‘Joe’ as CustomerName
union select 2, ‘3/1/2012’, 11.00, ‘Sam’
union select 3, ‘3/2/2012’, 10.00, ‘Beth’
union select 4, ‘3/2/2012’, 15.00, ‘Joe’
union select 5, ‘3/2/2012’, 17.00, ‘Sam’
union select 6, ‘3/3/2012’, 12.00, ‘Joe’
union select 7, ‘3/4/2012’, 10.00, ‘Beth’
union select 8, ‘3/4/2012’, 18.00, ‘Sam’
union select 9, ‘3/4/2012’, 12.00, ‘Joe’
union select 10, ‘3/4/2012’, 11.00, ‘Beth’
union select 11, ‘3/5/2012’, 14.00, ‘Sam’
union select 12, ‘3/6/2012’, 17.00, ‘Beth’
union select 13, ‘3/6/2012’, 19.00, ‘Joe’
union select 14, ‘3/7/2012’, 13.00, ‘Beth’
union select 15, ‘3/7/2012’, 16.00, ‘Sam’
)
select OrderID
,OrderDate
,OrderAmt
,CustomerName
from CTEOrders;

Position Value Functions: LAG, LEAD, FIRST_VALUE, LAST_VALUE

Who has not needed to use values from other rows in the current row for a report or other query? A prime example is needing to know what the last order value was to calculate growth or just show the difference in the results. This has never been easy in SQL Server until now. All of these functions require the use of the OVER clause and the ORDER BY clause. They all use the current row within the partition to find the row at the desired position.

The LAG and LEAD functions allow you to specify the offset or how many rows to look forward or backward and they support a default value in cases where the value returned would be null. These functions do not support the use of ROWS or RANGE in the OVER clause. The FIRST_VALUE and LAST_VALUE allow you to further define the partition using ROWS or RANGE if desired.

The following example illustrates all of the functions with various variations on the parameters and settings.

select OrderID
,OrderDate
,OrderAmt
,CustomerName
,LAG(OrderAmt) OVER (PARTITION BY CustomerName ORDER BY OrderID) as PrevOrdAmt
,LEAD(OrderAmt, 2) OVER (PARTITION BY CustomerName ORDER BY OrderID) as NextTwoOrdAmt
,LEAD(OrderDate, 2, ‘9999-12-31’) OVER (PARTITION BY CustomerName ORDER BY OrderID) as NextTwoOrdDtNoNull
,FIRST_VALUE(OrderDate) OVER (ORDER BY OrderID) as FirstOrdDt
,LAST_VALUE(CustomerName) OVER (PARTITION BY OrderDate ORDER BY OrderID) as LastCustToOrdByDay
from CTEOrders

Results (with shortened column names):

ID	OrderDate	Amt	Cust	PrevOrdAmt	NextTwoAmt	NextTwoDt	FirstOrd	LastCust
1	3/1/2012	10	Joe	NULL	12	3/3/2012	3/1/2012	Joe
2	3/1/2012	11	Sam	NULL	18	3/4/2012	3/1/2012	Sam
3	3/2/2012	10	Beth	NULL	11	3/4/2012	3/1/2012	Beth
4	3/2/2012	15	Joe	10	12	3/4/2012	3/1/2012	Joe
5	3/2/2012	17	Sam	11	14	3/5/2012	3/1/2012	Sam
6	3/3/2012	12	Joe	15	19	3/6/2012	3/1/2012	Joe
7	3/4/2012	10	Beth	10	17	3/6/2012	3/1/2012	Beth
8	3/4/2012	18	Sam	17	16	3/7/2012	3/1/2012	Sam
9	3/4/2012	12	Joe	12	NULL	12/31/9999	3/1/2012	Joe
10	3/4/2012	11	Beth	10	13	3/7/2012	3/1/2012	Beth
11	3/5/2012	14	Sam	18	NULL	12/31/9999	3/1/2012	Sam
12	3/6/2012	17	Beth	11	NULL	12/31/9999	3/1/2012	Beth
13	3/6/2012	19	Joe	12	NULL	12/31/9999	3/1/2012	Joe
14	3/7/2012	13	Beth	17	NULL	12/31/9999	3/1/2012	Beth
15	3/7/2012	16	Sam	14	NULL	12/31/9999	3/1/2012	Sam

If you really like subselects, you can also mix in some subselects and have a very creative SQL statement. The following statement uses LAG and a subselect to find the first value in a partition. I am showing this to illustrate some more of the capabilities of the function in case you have a solution that requires this level of complexity.

select OrderID
,OrderDate
,OrderAmt
,CustomerName
,LAG(OrderAmt, (
select count(*)-1
from CTEOrders c
where c.CustomerName = CTEOrders.CustomerName
and c.OrderID <= CTEOrders.OrderID), 0)
OVER (PARTITION BY CustomerName ORDER BY OrderDate, OrderID) as FirstOrderAmt
FROM CTEOrders

Percentile Functions: CUME_DIST, PERCENT_RANK, PERCENTILE_CONT, PERCENTILE_DISC

As I wrap up my discussion on window functions, the percentile based functions were the functions I knew the least about. While I have already used the position value functions above, I have not yet needed to use the percentiles. So, that meant I had to work with them for a while so I could share their usage and have some samples for you to use.

The key differences in the four function have to do with ranks and values. CUME_DIST and PERCENT_RANK return a ranking value while PERCENTILE_CONT and PERCENTILE_DISC return data values.

CUME_DIST returns a value that is greater than zero and lest than or equal to one (>0 and <=1) and represents the percentage group that the value falls into based on the order specified. PERCENT_RANK returns a value between zero and one as well (>= 0 and <=1). However, in PERCENT_RANK the first group is always represented as 0 whereas in CUME_DIST it represents the percentage of the group. Both functions return the last percent group as 1. In both cases, as the ranking percentages move from lowest to highest, each group’s percent value includes all of the earlier values in the calculation as well.

The following statement shows both of the functions using the default partition to determine the rankings of order amounts within our dataset.

select OrderID
,OrderDate
,OrderAmt
,CustomerName
,CUME_DIST() OVER (ORDER BY OrderAmt) CumDist
,PERCENT_RANK() OVER (ORDER BY OrderAmt) PctRank
FROM CTEOrders

Results:

OrderID	OrderDate	OrderAmt	CustomerName	CumDist	PctRank
1	3/1/2012	10	Joe	0.2	0
3	3/2/2012	10	Beth	0.2	0
7	3/4/2012	10	Beth	0.2	0
2	3/1/2012	11	Sam	0.33333333	0.214285714
10	3/4/2012	11	Beth	0.33333333	0.214285714
6	3/3/2012	12	Joe	0.46666667	0.357142857
9	3/4/2012	12	Joe	0.46666667	0.357142857
14	3/7/2012	13	Beth	0.53333333	0.5
11	3/5/2012	14	Sam	0.6	0.571428571
4	3/2/2012	15	Joe	0.66666667	0.642857143
15	3/7/2012	16	Sam	0.73333333	0.714285714
5	3/2/2012	17	Sam	0.86666667	0.785714286
12	3/6/2012	17	Beth	0.86666667	0.785714286
8	3/4/2012	18	Sam	0.93333333	0.928571429
13	3/6/2012	19	Joe	1	1

The last two functions, PERCENTILE_CONT and PERCENTILE_DISC, return the value at the percentile requested. PERCENTILE_CONT will return the true percentile value whether it exists in the data or not. For instance, if the percentile group has the values 10 and 20, it will return 15. If PERCENTILE_DISC, is applied to the same group it will return 10. It will return the smallest value in the percentile group, which in this case is 10. Both functions ignore NULL values and do not use the ORDER BY, ROWS, or RANGE clauses with the PARTITION BY clause. Instead, WITHIN GROUP is introduced which must contain a numeric data type and ORDER BY clause. Only one column can be specified here. Both functions need a percentile value which can be between 0.0 and 1.0.

The following script illustrates a couple of variations. The first two functions return the median of the default partition. Then next two return the median value for each day. Finally, the last two functions return the low and high values within the partition. The values segmented by the date partition highlight the key difference between the two functions.

select OrderID as ID
,OrderDate as ODt
,OrderAmt as OAmt
,CustomerName as CName
,PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY OrderAmt) OVER() PerCont05
,PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY OrderAmt) OVER() PerDisc05
,PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY OrderAmt) OVER(PARTITION BY OrderDate) PerContDt
,PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY OrderAmt) OVER(PARTITION BY OrderDate) PerDiscDt
,PERCENTILE_CONT(0) WITHIN GROUP (ORDER BY OrderAmt) OVER() PerCont0
FROM CTEOrders

Results

ID	ODt	OAmt	CName	PerCont05	PerDisc05	PerContDt	PerDiscDt	PerCont0
1	3/1/2012	10	Joe	13	13.00	10.5	10.00	10
2	3/1/2012	11	Sam	13	13.00	10.5	10.00	10
3	3/2/2012	10	Beth	13	13.00	15.0	15.00	10
4	3/2/2012	15	Joe	13	13.00	15.0	15.00	10
5	3/2/2012	17	Sam	13	13.00	15.0	15.00	10
6	3/3/2012	12	Joe	13	13.00	12.0	12.00	10
7	3/4/2012	10	Beth	13	13.00	11.5	11.00	10
10	3/4/2012	11	Beth	13	13.00	11.5	11.00	10
9	3/4/2012	12	Joe	13	13.00	11.5	11.00	10
8	3/4/2012	18	Sam	13	13.00	11.5	11.00	10
11	3/5/2012	14	Sam	13	13.00	14.0	14.00	10
12	3/6/2012	17	Beth	13	13.00	18.0	17.00	10
13	3/6/2012	19	Joe	13	13.00	18.0	17.00	10
14	3/7/2012	13	Beth	13	13.00	14.5	13.00	10
15	3/7/2012	16	Sam	13	13.00	14.5	13.00	10

As I wrap up this post, I have to give a shout out to my daughter, Kristy, who is an honors math student. She helped me get my head around this last group of functions. Her honors math work and some statistical work she had done in science helped provide additional insight into the math behind the functions. (Kristy – you rock!)

Series Wrap Up

I hope this series helps everyone understand the power and flexibility in the window functions made available in SQL Server 2012. If you happen to use Oracle, I know that many of these functions or there equivalent are also available in 11g and they also appear to be in 10g. I have to admit my first real production usage was with Oracle 11g but has since used them with SQL Server 2012. The expanded functionality in SQL Server 2012 is just one more reason to upgrade to the latest version.

T-SQL Window Functions – Part 3: Aggregate Functions

This is a reprint with some revisions of a series I originally published on LessThanDot. You can find the links to the original blogs on my Series page.

This is part 3 in my series on SQL window functions. In this post, we will explore using aggregation functions with T-SQL windows. SQL Server supports most of the aggregation functions such as SUM and AVG in this context with the exceptions of GROUPING and GROUPING_ID. However, prior to SQL Server 2012 only the PARTITION BY clause was supported which greatly limited the usability of aggregate window functions. When support for the ORDER BY clause was introduced in SQL Server 2012, more complex business problems such as running totals could be solved without the extensive use of cursors or nested select statement. In my experience, I used to try various ways to get around this limitation including pushing the data to .NET as it could solve this problem more efficiently. However, this was not always possible when working with reporting. Now that we are able to use SQL to solve the problem, more complex and low-performing solutions can be replaced with these window functions.

Once again, the following CTE will be used as the query in all examples throughout the post:

with CTEOrders as
(select cast(1 as int) as OrderID, cast(‘3/1/2012’ as date) as OrderDate, cast(10.00 as money) as OrderAmt, ‘Joe’ as CustomerName
union select 2, ‘3/1/2012’, 11.00, ‘Sam’
union select 3, ‘3/2/2012’, 10.00, ‘Beth’
union select 4, ‘3/2/2012’, 15.00, ‘Joe’
union select 5, ‘3/2/2012’, 17.00, ‘Sam’
union select 6, ‘3/3/2012’, 12.00, ‘Joe’
union select 7, ‘3/4/2012’, 10.00, ‘Beth’
union select 8, ‘3/4/2012’, 18.00, ‘Sam’
union select 9, ‘3/4/2012’, 12.00, ‘Joe’
union select 10, ‘3/4/2012’, 11.00, ‘Beth’
union select 11, ‘3/5/2012’, 14.00, ‘Sam’
union select 12, ‘3/6/2012’, 17.00, ‘Beth’
union select 13, ‘3/6/2012’, 19.00, ‘Joe’
union select 14, ‘3/7/2012’, 13.00, ‘Beth’
union select 15, ‘3/7/2012’, 16.00, ‘Sam’
)
select OrderID
,OrderDate
,OrderAmt
,CustomerName
from CTEOrders;

Using PARTITION BY with Aggregate Functions

SQL Server 2005 and the newer versions supports the usage of the PARTITION BY clause by itself. This allowed for some simple aggregate windows. The following example shows SUM and AVG for different partitions of data. The third function actually creates and average using a SUM and COUNT function.

select CustomerName
,OrderDate
,OrderAmt
,SUM(OrderAmt) OVER (PARTITION BY CustomerName) CustomerTotal
,AVG(OrderAmt) OVER (PARTITION BY OrderDate) AvgDailyAmt
,CAST(COUNT(OrderID) OVER (PARTITION BY OrderDate) as decimal(8,3)) / CAST(COUNT(OrderID) OVER() as decimal(8,3)) PctOfTotalPerDay
from CTEOrders
order by OrderDate;

NOTE: The COUNT aggregate returns an integer value. In order to return the decimal, the values need to be explicitly converted to decimal types. Otherwise, the result was rounding to zero for all results in this sample.

Results

CustomerName	OrderDate	OrderAmt	CustomerTotal	AvgDailyAmt	PctOfTotalPerDay
Joe	3/1/2012	10	68	10.5	0.133333333
Sam	3/1/2012	11	76	10.5	0.133333333
Sam	3/2/2012	17	76	14	0.2
Joe	3/2/2012	15	68	14	0.2
Beth	3/2/2012	10	61	14	0.2
Joe	3/3/2012	12	68	12	0.066666667
Joe	3/4/2012	12	68	12.75	0.266666667
Beth	3/4/2012	10	61	12.75	0.266666667
Beth	3/4/2012	11	61	12.75	0.266666667
Sam	3/4/2012	18	76	12.75	0.266666667
Sam	3/5/2012	14	76	14	0.066666667
Beth	3/6/2012	17	61	18	0.133333333
Joe	3/6/2012	19	68	18	0.133333333
Beth	3/7/2012	13	61	14.5	0.133333333
Sam	3/7/2012	16	76	14.5	0.133333333

Using Subselects

Subselect statements in SQL Server are supported, but harder to optimize in SQL Server versus Oracle. Until window functions were introduced all of the situations above could be solved by subselects, but performance would degrade as the results needed to work with larger sets of data. With the improved functionality in SQL Server 2012, you should not need to use subselects to return row-based aggregations. Besides the performance implications, maintenance will also be much simpler as the SQL becomes more transparent. For reference, here is the subselect syntax to return the same results as above:

select cte.CustomerName
, cte.OrderDate
, cte.OrderAmt
, (select SUM(OrderAmt) from CTEOrders where CustomerName = cte.CustomerName) CustomerTotal
, (select cast(COUNT(OrderID) as decimal(8,3)) from CTEOrders where OrderDate = cte.OrderDate) / (select cast(COUNT(OrderID) as decimal(8,3)) from CETOrders) AvgDailyAmt
from CETOrders cte
order by cte.OrderDate;

While it is possible to solve the same function using the subselects, the code is already getting messier and with data sets larger than what we have here, you would definitely see performance degradation.

Some Thoughts on GROUP BY

While I am digressing, I wanted to also highlight some details concerning GROUP BY. The one the biggest difficulties working with the GROUP BY clause and aggregates, every column must either be a part of the GROUP BY or have an aggregation associated with it. The window functions help solve this problem as well.
In the following examples, the first query returns the sum of the amount by day. This is pretty standard logic when working with aggregated queries in SQL.

select OrderDate
,sum(OrderAmt) as DailyOrderAmt
from CTEOrders
group by OrderDate;

However, if you wanted to see more details, but not include them in the aggregation, the following will not work.

select OrderDate
,OrderID
,OrderAmt
,sum(OrderAmt) as DailyOrderAmt
from CTEOrders
group by OrderDate
,OrderID
,OrderAmt;

This SQL statement will return each row individually with the sum at the detail level. You can solve this using the subselect above which is not recommended or you can use a window function.

select OrderDate
,OrderID
,OrderAmt
,sum(OrderAmt) OVER (PARTITION BY OrderDate) as DailyOrderAmt
from CTEOrders

As you can see here and in previous examples the OVER clause allows you to manage the grouping based on the context specified in relationship to the current row.

One other twist on the GROUP BY clause. First, I need to give credit to Itzik Ben-Gan for calling this to my attention at one of our Minnesota SQL Server User Group meetings. In his usual fashion he was showing some T-SQL coolness and he showed an interesting error when using the OVER clause with the GROUP BY clause.

The following will return an error because the first expression is an aggregate, but the second expression which is using the OVER clause is not. Also note that in this example the OVER clause is being evaluated for the entire set of data.

select sum(OrderAmt)
, sum(OrderAmt) over() as TotalOrderAmt
from CTEOrders
group by CustomerName

The expression above returns the following error:
Column ‘CTEOrders.OrderAmt’ is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause

The goal of the statement above was to show the customer’s total order amount with the overall order amount. The following statement resolves this issue because it is aggregating the aggregates. The window is now summing the aggregated amount which are grouped on the customer name.

select sum(OrderAmt)
, sum(sum(OrderAmt)) over() as TotalOrderAmt
from CTEOrders
group by CustomerName

Thanks again to Itzik for bringing this problem and resolution to my attention.

Aggregates with ORDER BY

With the expansion of the OVER clause to include ORDER BY support with aggregates, window functions increased their value substantially. One of the key business problems this allowed us to solve was a running aggregate.

The first example shows how to get a running total by CustomreName based on OrderDate and OrderID.

select OrderID
,OrderDate
,OrderAmt
,CustomerName
,SUM(OrderAmt) OVER (PARTITION BY CustomerName ORDER BY OrderDate, OrderID) as RunningByCustomer
from CTEOrders
ORDER BY CustomerName, OrderDate;

Results

OrderID	OrderDate	OrderAmt	CustomerName	RunningByCustomer
3	3/2/2012	10	Beth	10
7	3/4/2012	10	Beth	20
10	3/4/2012	11	Beth	31
12	3/6/2012	17	Beth	48
14	3/7/2012	13	Beth	61
1	3/1/2012	10	Joe	10
4	3/2/2012	15	Joe	25
6	3/3/2012	12	Joe	37
9	3/4/2012	12	Joe	49
13	3/6/2012	19	Joe	68
2	3/1/2012	11	Sam	11
5	3/2/2012	17	Sam	28
8	3/4/2012	18	Sam	46
11	3/5/2012	14	Sam	60
15	3/7/2012	16	Sam	76

This next example is more creative. It begins to show how powerful the window functions are. In this statement, we are going to return the annual running total aggregated by day. The differentiator here is that we use a DATEPART function in the OVER clause to achieve the desired results.

select OrderID
,OrderDate
,OrderAmt
,CustomerName
,SUM(OrderAmt) OVER (PARTITION BY datepart(yyyy, OrderDate) ORDER BY OrderDate) as AnnualRunning
from CTEOrders
ORDER BY OrderDate;

Results

OrderID	OrderDate	OrderAmt	CustomerName	AnnualRunning
1	3/1/2012	10	Joe	21
2	3/1/2012	11	Sam	21
3	3/2/2012	10	Beth	63
4	3/2/2012	15	Joe	63
5	3/2/2012	17	Sam	63
6	3/3/2012	12	Joe	75
7	3/4/2012	10	Beth	126
8	3/4/2012	18	Sam	126
9	3/4/2012	12	Joe	126
10	3/4/2012	11	Beth	126
11	3/5/2012	14	Sam	140
12	3/6/2012	17	Beth	176
13	3/6/2012	19	Joe	176
14	3/7/2012	13	Beth	205
15	3/7/2012	16	Sam	205

The ORDER BY clause creates an expanding group within the partition. In the examples above, the partition was the customer. Within each partition, ordered groups based on OrderDate and OrderID are “created”. At each row, the OrderDate and OrderID groups are aggregated up to the current row’s group thus producing the running total. If more than one row has the same order grouping, all of the rows in the group are aggregated into the total as shown in the second example above with the days and years.

Aggregates with ROWS

The ROWS clause is used to further define the partition by specifying which physical rows to include based on their proximity to the current row. As noted in the first post in the series, ROWS requires the ORDER BY clause as this determines the orientation of the partition.

The following example uses the FOLLOWING keywords to find the next two purchases that the customer made.

select OrderID
,OrderDate
,OrderAmt
,CustomerName
,SUM(OrderAmt) OVER (PARTITION BY CustomerName ORDER BY OrderDate, OrderID ROWS BETWEEN 1 FOLLOWING and 2 FOLLOWING) as NextTwoAmts
from CTEOrders
order by CustomerName, OrderDate, OrderID;

Results

OrderID	OrderDate	OrderAmt	CustomerName	NextTwoAmts
3	3/2/2012	10	Beth	21
7	3/4/2012	10	Beth	28
10	3/4/2012	11	Beth	30
12	3/6/2012	17	Beth	13
14	3/7/2012	13	Beth	NULL
1	3/1/2012	10	Joe	27
4	3/2/2012	15	Joe	24
6	3/3/2012	12	Joe	31
9	3/4/2012	12	Joe	19
13	3/6/2012	19	Joe	NULL
2	3/1/2012	11	Sam	35
5	3/2/2012	17	Sam	32
8	3/4/2012	18	Sam	30
11	3/5/2012	14	Sam	16
15	3/7/2012	16	Sam	NULL

As we noted in the first blog, the last two rows in the partition only contain partial values. For example, order 12 contains the sum of only one order, 14, and order 14 has now rows following it in the partition and returns NULL as a result. When working with the ROWS clause this must be taken into account.

Aggregates with RANGE

Lastly, adding the RANGE to the OVER clause allows you to create aggregates which go to the beginning or end of the partition. RANGE is commonly used with UNBOUNDED FOLLOWING which goes to the end of the partition and UNBOUNDED PRECEDING which goes to the beginning of the partition. One of the most common use would be to specify the rows from the beginning of the partition to the current row which allows for aggregations such as year to date.

In the example below, we are calculating the average order size over time to the current row. This could be a very effective in a trending report.

select OrderID
,OrderDate
,OrderAmt
,CustomerName
,AVG(OrderAmt) OVER (ORDER BY OrderID RANGE BETWEEN UNBOUNDED PRECEDING and CURRENT ROW) as AvgOrderAmt
from CTEOrders
order by OrderDate;

Results

OrderID	OrderDate	OrderAmt	CustomerName	AvgOrderAmt
1	3/1/2012	10	Joe	10
2	3/1/2012	11	Sam	10.5
3	3/2/2012	10	Beth	10.333333
4	3/2/2012	15	Joe	11.5
5	3/2/2012	17	Sam	12.6
6	3/3/2012	12	Joe	12.5
7	3/4/2012	10	Beth	12.142857
8	3/4/2012	18	Sam	12.875
9	3/4/2012	12	Joe	12.777777
10	3/4/2012	11	Beth	12.6
11	3/5/2012	14	Sam	12.727272
12	3/6/2012	17	Beth	13.083333
13	3/6/2012	19	Joe	13.538461
14	3/7/2012	13	Beth	13.5
15	3/7/2012	16	Sam	13.666666

As you can see, the latest versions of OVER clause supports powerful yet simple aggregations which can help in a multitude of reporting and business solutions. Up next, the last blog in the series – Analytic Functions which are all new in SQL Server 2012.