SQL Aggregation for a smaller result set - sql

Question

I have a database for which I need to aggregate records into another smaller set. This result set should contain the difference between maximum and minumum of specific columns of the original records where they add up to certain SUM, a closed interval constant C.
The constant C determines how the original records are aggregated and no entry in the resulting set ever exceeds it. Naturally I am supposed to run this in natural primary key order..
To illustrate: table has:
[key]
[a]
[b]
[minColumn]
[maxColumn]
[N]
...all are int datatype.
I am after a result set that has entries where the MAX(maxColumn) - MIN(minColumn) for that group such that when their difference is summed up it is less or equal to constant C.
Apart from the MAX(maxColumn) and MIN(minColumn) value I also need the FIRST record column [a] and LAST record column [b] values before creating a new entry in this result set. Finally, the N column should be SUMmed for all original records in a group.
Is there an efficient way to do this without cursors?
-----[Trivial Sample]------------------------------------------------------------
I am attempting to group-by a slightly complicated form of a running sum, constant C.
There is only one table, columns are all of int type and sample data
declare #t table (
PK int primary key
, int a, int b, int minColumn, int maxColumn, int N
)
insert #t values (1,5,6,100,200,1000)
insert #t values (2,7,8,210,300,2000)
insert #t values (3,9,10,420,600,3000)
insert #t values (4,11,12,640,800,4000)
Thus for:
key, a, b, minColumn, maxColumn, N
---------------------------------------
1, 5, 6, 100, 200, 1000
2, 7, 8, 210, 300, 2000
3, 9, 10, 420, 600, 3000
4, 11, 12, 640, 800, 4000
I need the result set to look like, for a constant C of 210 :
firstA | lastB | MIN_minColumn | MAX_maxColumn | SUM_N
5 8 100 300 3000
9 10 420 600 3000
11 12 640 800 4000
[ Adding the bounty and sample as discussed below]
For C = 381, It should contain 2 rows:
firstA | lastB | MIN_minColumn | MAX_maxColumn | SUM_N
5 8 100 300 3000
9 12 420 800 7000
Hope this demonstrates the problem better.. and for a constant C say 1000 you would get 1 record in the result:
firstA | lastB | MIN_minColumn | MAX_maxColumn | SUM_N
5 12 100 800 10000

Answer 1

DECLARE #c int
SELECT #c = 210
SELECT MIN(a) firstA,
MAX(b) lastB,
MIN(minColumn) MIN_minColumn,
MAX(maxColumn) MAX_maxColumn,
SUM(N) SUM_N
FROM #t t
JOIN (SELECT key, floor(sum/#c) as rank
FROM (SELECT key,
(SELECT SUM(t2.maxColumn - t2.minColumn)
FROM #t t2
WHERE t2.key <= t1.key
GROUP BY t1.key) as sum
FROM #t t1) A
) B on B.key = t.key
GROUP BY B.rank
/*
Table A: for each key, calculating SUM[maxColumn-minColumn] of all keys below it.
Table B: for each key, using the sum in A, calculating a rank so that:
sum = (rank + y)*#c where 0 <= y < 1.
ex: #c=210, rank(100) = 0, rank(200) = 0, rank(220) = 1, ...
finally grouping by rank, you'll have what you want.
*/

Answer 2

declare #c int
select #c = 210
select firstA = min(a), lastB = max(b), MIN_minColumn = min(minColumn), MAX_maxColumn = max(maxColumn), SUM_N = sum(N)
from #t
where minColumn <= #c
union all
select a, b, minColumn, maxColumn, N
from #t
where minColumn > #c

Answer 3

I am a little confused on the grouping logic for result you are trying to produce, but from the description of what you are looking for, I think you need a HAVING clause. You should be able to do something like:
SELECT groupingA, groupingB, MAX(a) - MIN(b)
FROM ...
GROUP BY groupingA, groupingB
HAVING (MAX(a) - MIN(b)) < C
...in order to filter out the difference between your max and min values, once you've determined your grouping. Hope this is helpful