SQL Sum over partition

Question

I have 6000 pieces of a stock item and the stock is split into 2 batches containing 4000 pieces and 2000 pieces.

Based on sales orders I am trying to predict which batch of stock will fulfil each order.

For example:

SELECT product, order_qty, price, date_required FROM orders Where product = 'X'

This produces this table:

product | order_qty | price |  date_required
------------------------------------------------------
 X      | 300       | 1.01  |   01/07/2018
 X      | 500       | 1.00  |   03/07/2018
 X      | 700       | 1.05  |   02/07/2018
 X      | 1000      | 1.00  |   01/08/2018
 X      | 2000      | 1.00  |   20/07/2018
 X      | 600       | 1.06  |   10/07/2018
 X      | 500       | 1.10  |   11/07/2018
 X      | 400       | 1.00  |   10/08/2018

Then I have another query for example:

SELECT batch, product, qty, date_received FROM batches where product = 'X'

This would produce a table like this:

 batch  |product| qty   |  date_received
-------------------------------------------
 ABC123 | X     | 2000  |   01/04/2018
 987ZYX | X     | 4000  |   01/01/2018

So using these two tables I'd like to predict which batch of stock order would pick from. The stock is using a FIFO system, so based on the table it would have to fulfil the orders using the batch code 987ZYX batch first. I'm looking for a query that produces this as a table:

product | order_qty | price |  date_required|   batch
------------------------------------------------------------------
 X      | 300       | 1.01  |   01/07/2018  |   987ZYX
 X      | 500       | 1.00  |   03/07/2018  |   987ZYX  
 X      | 700       | 1.05  |   02/07/2018  |   987ZYX
 X      | 1000      | 1.00  |   01/08/2018  |   ABC123
 X      | 2000      | 1.00  |   20/07/2018  |   987ZYX & ABC123
 X      | 600       | 1.06  |   10/07/2018  |   987ZYX
 X      | 500       | 1.10  |   11/07/2018  |   987ZYX
 X      | 400       | 1.00  |   10/08/2018  |   ABC123

I have selected the batches above based on the required date, for example the first order that is required is 1/7/18 so that would remove 300 pieces from batch 987ZYX, then I continued in this method until I had to fulfil the order from the next batch

I understand I could use the SUM over method, but how could I use this to make sure it doesn't use more stock than is available in the batch, as you can see above I'd like to display two batches if possible if it will need to fulfil from two.

Answer 1

First, I hate dates (partially cause my birthday is on February 29, partially because my 'd' key is not working properly), so I created index for each order and each batch, and I assume that orders should be processed in the increasing order of the index from minimum possible batch index. I also don't check if the items are in stock at the time of the order, as well as many other things.

As @GordonLinoff suggested, we will use cumulative sums. I create new tables with cumulative quantity for tables #orders and #batch (we just sum up all quantity from orders/batches with id up to current). And then we recursively calculate the batch that ... well, we somehow find the necessary batch. I guess we don't need recursion, but I just learnt how to use it in SQL, so I'm proud to use it in unnecessary places. Oh, and I also forgot to check if the product from batch and orders is the same...

drop table if exists #orders, #batch, #orders_cumulative, #batch_cumulative

create table #orders (id int, product varchar(10), order_qty int, price float, date_required date)
insert into #orders VALUES
(1, 'x', 300, 1.01, '20180107'),
(2, 'y', 500, 1, '20180307'),
(3, 'x', 700, 1.05, '20180207'),
(4, 'x', 1000, 1, '20180108'),
(5, 'x', 2000, 1, '20180402'),
(6, 'x', 600, 1.06, '20180302'),
(7, 'y', 100, 1, '20180203'),
(8, 'x', 100, 1, '20180402')

create table #batch (id int, batch varchar(10), product varchar(10), qty int)
insert into #batch VALUES
(1, 'abc', 'x', 1000),
(2, 'zxc', 'x', 1000),
(3, 'sd', 'x', 2000),
(4, 'eiso', 'y', 10000)

SELECT  o.*
        ,(select sum(order_qty) from #orders where id <= o.id and product = o.product) cumulative_qty
INTO    #orders_cumulative
from    #orders o

select  b.*
        ,isnull((select sum(qty) from #batch where id < b.id and product = b.product), 0) cumulative_ex_qty
        ,(select sum(qty) from #batch where id <= b.id and product = b.product) cumulative_qty
into    #batch_cumulative
FROM    #batch b

select top 10 * from #orders_cumulative
select top 10 * from #batch_cumulative

select  oc.*
        ,case when bc.cumulative_ex_qty > oc.cumulative_qty - oc.order_qty then convert(varchar(10), isnull(b1.batch, '') + ', ' + b2.batch) else b2.batch end batch
from    #orders_cumulative oc 
join    #batch_cumulative bc on oc.cumulative_qty between bc.cumulative_ex_qty and bc.cumulative_qty and oc.product = bc.product
join    #batch b2 on b2.id = bc.id 
left JOIN   #batch b1 on b1.id = bc.id - 1

EDIT: I corrected the major issues (separated calculations for each product, eliminated stupid recursion) except the datetime being changed to id.