T-SQL 2012 Window Functions in ELT (part 3) - calculating price elasticity

Technical Value

SQL Server 2012

To complete this short series about SQL Server 2012 window functions for ELT processing, I’d like to show an example of a calculation typically needed in retail for measuring the responsiveness of the sales quantity to changes in the unit prices. This measure is called the price elasticity of demand. There are different methods for calculating the price elasticity. A simple one is to divide the percentage increase of quantity by the percentage increase of the unit price. Assuming Q1 was the quantity before the price change, Q2 is the quantity after the price change and P1 and P2 are the corresponding unit prices, the elasticity can be calculated using this formula:


For example, if the unit price is raised by 5% and you see a change in the sales quantity of –10%, then the elasticity would compute to –10%/5% = –2. In most cases, the elasticity is a negative value, as a higher price usually results in a smaller amount of goods being sold. There are other methods of calculating the price elasticity (point elasticity, arc elasticity) but I don’t want to focus on this too much here.

Some approaches are computing price elasticity by product only ignoring the fact that for most cases the responsiveness of the sales quantity to changes in the unit price significantly depends on the unit price. If the product is much cheaper than the same product from the competitors a price increase of 10% may have no effect at all (it’s still cheap). However, if the price increase leads to a price which is higher than the price from the competitors you may see a totally different effect for the sales quantity. So, for this example, we like to compute the price elasticity by the unit price of each product.

For the calculation we basically need the sales quantity by price and product. Although the AdventureWorks sample database does not provide a good data source for this purpose, I will still show an example based on this data because it is widely available. Let’s try the reseller fact table here:

  1. select      
  2.     ProductKey      
  3.     , UnitPrice      
  4.     , Sum(OrderQuantity) OrderQuantity      
  6. from      
  7.      [dbo].[FactResellerSales]      
  9. group by ProductKey, UnitPrice      
  10. order by ProductKey, UnitPrice

The result of the query shows the total quantity by price and product:


As you can see, the order quantity is different for different unit prices. However, we cannot really compare the order quantities for different prices using the query from above. The reason is simple. Imagine you have a product with a price of 1.5 EUR being sold for 12 weeks at a total of 1000 pieces per week. Now for only one week you change the price to 1.2 EUR and observe a higher demand of 2000 pieces. Using the query from above would give the following result

Product Unit Price Quantity
My Product 1.5 EUR


My Product 1.2 EUR


Just using the total quantity by unit price would lead to the wrong conclusion that lowering the price from 1.5 to 1.2 EUR leads to less sales. So I think it’s clear that we need to normalize the results before being able to compare them. For example, if we normalize by the number we weeks here, we get the desired result:

Product Unit Price Quantity By Week
My Product 1.5 EUR


My Product 1.2 EUR


Is time the only dimension that needs to be normalized? Usually not. Imagine you have regional promotion where only 10 out of 100 stores sell the product at the price of 1.2 EUR. Again the 90 stores selling at 1.5 EUR cannot be compared to the 10 stores selling at 1.2 EUR.

Usually we need to normalize our results by

  • Number of days the product is being sold
  • Number of stores that are selling the product

As a consequence, for our example that is based on the ResellerFacts table in the AdventureWorks database, I’m going to modify the query from above as shown below:

  1. select      
  2.     ProductKey      
  3.     , UnitPrice 
  4.     , Avg(OrderQuantity) OrderQuantity      
  5. from      
  6.     (      
  7.     select ProductKey, UnitPrice, Sum(convert(float,[OrderQuantity])) OrderQuantity      
  8.     from [dbo].[FactResellerSales]      
  9.     group by ProductKey, UnitPrice, ResellerKey, OrderDateKey      
  10.     ) SalesDetails      
  11. group by ProductKey, UnitPrice      
  12. order by ProductKey, UnitPrice

The line in red shows aggregates the original data by product and unit price and also by reseller and order date where the latter two are important to separate the aggregates for the normalization. We don’t need ResellerKey or OrderDateKey in the output column list, we only need to have separate rows. This allows us to compute an average quantity in the outer query. Here’s the result:


As you see, the values differ a lot from the results of the first query. For practical use, you would usually filter on a specific date range (for example the last 12 months) and also group by other attributes (for example region or even store if you have enough data). To keep things simple, I’m not going to do this here.

In order to do the calculation of the elasticity, we need to fetch the previous unit price and order quantity together with the current one. This is where the window functions become helpful. In order to keep the results simple, I choose a single product here:

  1. select      
  2.     ProductKey      
  3.     , UnitPrice      
  4.     , Avg(OrderQuantity) OrderQuantity      
  5.     , lag(UnitPrice,1) over (partition by ProductKey order by UnitPrice) PrevUnitPrice      
  6.     , lag(Avg(OrderQuantity),1) over (partition by ProductKey order by UnitPrice) PrevOrderQuantity       
  7. from      
  8.     (      
  9.     select ProductKey, UnitPrice, Sum(convert(float,[OrderQuantity])) OrderQuantity      
  10.     from [dbo].[FactResellerSales]      
  11.     group by ProductKey, UnitPrice, ResellerKey, OrderDateKey      
  12.     ) SalesDetails      
  13. where ProductKey=470      
  14. group by ProductKey, UnitPrice      
  15. order by ProductKey, UnitPrice


The unit price and the order quantity can be used to plot the demand curve , that shows the relationship between price and sales quantity.


The higher the price, the lower the sales quantity for most cases. So the graph shows exactly what we have expected. Usually the demand curve is not that linear as it is in my example here.

Let’s get back to the computation of the price elasticity. What you can see in the example from above is that a price change form 17.0955 to 18.995 results in a change of quantity from 44 down to 30.45. Using the formula from above the elasticity would compute as


In order to complete the computation of the price elasticity, I’m going to wrap the query from above into a CTE:

  1. with SalesByPrice as (      
  2. select      
  3.     ProductKey      
  4.     , UnitPrice      
  5.     , Avg(OrderQuantity) OrderQuantity      
  6.     , lag(UnitPrice,1) over (partition by ProductKey order by UnitPrice) PrevUnitPrice      
  7.     , lag(Avg(OrderQuantity),1) over (partition by ProductKey order by UnitPrice) PrevOrderQuantity       
  8. from      
  9.     (      
  10.     select ProductKey, UnitPrice, Sum(convert(float,[OrderQuantity])) OrderQuantity      
  11.     from [dbo].[FactResellerSales]      
  12.     group by ProductKey, UnitPrice, ResellerKey, OrderDateKey      
  13.     ) SalesDetails      
  14. where ProductKey=470      
  15. group by ProductKey, UnitPrice      
  16. )


  1. select    
  2.     ProductKey      
  3.     , UnitPrice      
  4.     , PrevUnitPrice      
  5.     , OrderQuantity, PrevOrderQuantity      
  6.     , case        
  7.             when coalesce(PrevUnitPrice,0)<>0 then        
  8.                 ((OrderQuantity-PrevOrderQuantity) / PrevOrderQuantity)        
  9.                 /        
  10.                 ((UnitPrice-PrevUnitPrice) / PrevUnitPrice)        
  11.             else null        
  12.       end PriceElasticity        
  13. from SalesByPrice      
  14. where ProductKey=470      
  15. order by ProductKey, UnitPrice

The actual calculation of the price elasticity is shown in red here. Here is the result:


What you can see here, is that for higher unit prices the sales quantity drops more significantly thus resulting in a higher (negative) price elasticity.

To finish this post, some remarks to the price elasticity: Although the computation is simple (especially if you’re using the window functions), for practical purposes the sales quantity is often corrected for example by seasonal effects, promotions (up-lift) or other effects. This gives a more realistic calculation for the price elasticity. You also need to monitor that you have enough sales data for each product to do this calculation. It doesn’t make much sense to group this calculation by store if you end up with only a few rows per price. And in order to plot this result one option would be do fill the gaps in the unit price (maybe also using window functions) so that you can compare different products regarding their price elasticity on the same axis. Filling the gaps also allows you to compute the price for the optimal profit if you also have the unit costs available. But this would be a separate topic which also can be challenging.

Neuen Kommentar schreiben

Der Inhalt dieses Feldes wird nicht öffentlich zugänglich angezeigt.


  • Keine HTML-Tags erlaubt.
  • HTML - Zeilenumbrüche und Absätze werden automatisch erzeugt.
  • Web page addresses and email addresses turn into links automatically.
Teilen auf

Newsletter Anmeldung

Abonnieren Sie unseren Newsletter!
Lassen Sie sich regelmäßig über alle Neuigkeiten rundum ORAYLIS und die BI- & Big-Data-Branche informieren.

Jetzt anmelden

Unsere Website benutzt Cookies, um bestmögliche Funktionalitäten bieten zu können. Durch die Nutzung unserer Website, erklären Sie sich mit der Verwendung von Cookies einverstanden. In unserer Datenschutzerklärung finden Sie unter §5 Informationen und Links, wie Sie diesen Maßnahmen jederzeit widersprechen können.