Comments on: How to divide consecutive rows into groups based on the value of the smallest running total in SQL http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/ Oracle Question and Answer Fri, 21 Nov 2008 00:47:38 +0000 http://wordpress.org/?v=2.6.3 By: JB318 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-223 JB318 Thu, 09 Aug 2007 16:36:46 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-223 Change the (5,7) in the input data to (5,8) and they're different again. Change the (5,7) in the input data to (5,8) and they’re different again.

]]> By: jan.stulrajter http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-222 jan.stulrajter Thu, 09 Aug 2007 13:11:13 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-222 OK, I found the difference. This is OK now? WITH x AS ( SELECT 1 id, 10 value FROM dual UNION ALL SELECT 2 id, 8 value FROM dual UNION ALL SELECT 3 id, 5 value FROM dual UNION ALL SELECT 4 id, 10 value FROM dual UNION ALL SELECT 5 id, 7 value FROM dual UNION ALL SELECT 6 id, 8 value FROM dual UNION ALL SELECT 7 id, 4 value FROM dual ) SELECT id,value, SUM(value) OVER(PARTITION BY grp ORDER BY id) running_tot, FIRST_VALUE (cnt)OVER(PARTITION BY grp ORDER BY id) group_id FROM(SELECT id,value,sum_cum, NVL(TRUNC(( sum_cum-value-1)/20),0) grp, COUNT(*) over(ORDER BY id) cnt FROM(SELECT id,value, SUM(value) over(ORDER BY id) sum_cum FROM x)) OK, I found the difference. This is OK now?

WITH x AS (
SELECT 1 id, 10 value FROM dual UNION ALL
SELECT 2 id, 8 value FROM dual UNION ALL
SELECT 3 id, 5 value FROM dual UNION ALL
SELECT 4 id, 10 value FROM dual UNION ALL
SELECT 5 id, 7 value FROM dual UNION ALL
SELECT 6 id, 8 value FROM dual UNION ALL
SELECT 7 id, 4 value FROM dual
)
SELECT
id,value,
SUM(value) OVER(PARTITION BY grp ORDER BY id) running_tot,
FIRST_VALUE (cnt)OVER(PARTITION BY grp ORDER BY id) group_id
FROM(SELECT
id,value,sum_cum,
NVL(TRUNC(( sum_cum-value-1)/20),0) grp,
COUNT(*) over(ORDER BY id) cnt
FROM(SELECT
id,value,
SUM(value) over(ORDER BY id) sum_cum
FROM x))

]]> By: JB318 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-221 JB318 Mon, 06 Aug 2007 16:23:17 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-221 OK, I needed to escape that less-than sign. Once more, with feeling... <pre> SQL> WITH x AS ( 2 SELECT 1 id, 10 value FROM dual UNION ALL 3 SELECT 2 id, 8 value FROM dual UNION ALL 4 SELECT 3 id, 5 value FROM dual UNION ALL 5 SELECT 4 id, 10 value FROM dual UNION ALL 6 SELECT 5 id, 7 value FROM dual UNION ALL 7 SELECT 6 id, 8 value FROM dual UNION ALL 8 SELECT 7 id, 4 value FROM dual 9 ) 10 SELECT id,value, Running_tot, group_id 11 FROM (SELECT id, value, Running_tot, group_id 12 FROM (SELECT id, value, count(*) OVER( ) counter, 13 ROW_NUMBER() OVER (ORDER BY id) rn FROM x) 14 MODEL 15 DIMENSION BY (rn) 16 MEASURES (id,value, counter,CAST(NULL AS NUMBER) Running_tot, 17 value tmp, CAST(NULL AS NUMBER) group_id, CAST(NULL AS NUMBER) rown ) 18 RULES ITERATE(10000) 19 UNTIL (ITERATION_NUMBER>= counter[1]) 20 ( 21 Running_tot[ITERATION_NUMBER] 22 = CASE WHEN tmp[ITERATION_NUMBER-1] IS NULL 23 THEN tmp[ITERATION_NUMBER] 24 ELSE tmp[ITERATION_NUMBER] + 25 Running_tot[cv()-1] 26 END, 27 tmp[ITERATION_NUMBER] = CASE WHEN Running_tot[ITERATION_NUMBER] < 20 /* input */ 28 THEN 0 29 END, 30 rown[ITERATION_NUMBER] = CASE WHEN Running_tot[CV()-1] IS NULL 31 THEN 1 32 WHEN tmp[ITERATION_NUMBER-1] IS NULL 33 THEN ITERATION_NUMBER 34 END, 35 group_id[ITERATION_NUMBER] = MAX(rown)[ANY] 36 ) 37 ) 38 WHERE id IS NOT NULL 39 ORDER BY id 40 / ID VALUE RUNNING_TOT GROUP_ID ---------- ---------- ----------- ---------- 1 10 10 1 2 8 18 1 3 5 23 1 4 10 10 4 5 7 17 4 6 8 25 4 7 4 4 7 7 rows selected. Elapsed: 00:00:00.01 </pre> OK, I needed to escape that less-than sign. Once more, with feeling…

SQL> WITH x AS (
  2          SELECT 1 id, 10 value FROM dual UNION ALL
  3          SELECT 2 id,  8 value FROM dual UNION ALL
  4          SELECT 3 id,  5 value FROM dual UNION ALL
  5          SELECT 4 id, 10 value FROM dual UNION ALL
  6          SELECT 5 id,  7 value FROM dual UNION ALL
  7          SELECT 6 id,  8 value FROM dual UNION ALL
  8          SELECT 7 id,  4 value FROM dual
  9  )
 10  SELECT id,value, Running_tot, group_id
 11    FROM (SELECT id, value, Running_tot, group_id
 12           FROM (SELECT id, value, count(*) OVER( ) counter,
 13                        ROW_NUMBER() OVER (ORDER BY id) rn FROM x)
 14   MODEL
 15   DIMENSION BY (rn)
 16   MEASURES (id,value, counter,CAST(NULL AS NUMBER) Running_tot,
 17             value tmp, CAST(NULL AS NUMBER) group_id, CAST(NULL AS NUMBER) rown )
 18   RULES ITERATE(10000)
 19   UNTIL (ITERATION_NUMBER>= counter[1])
 20   (
 21    Running_tot[ITERATION_NUMBER]
 22                          = CASE WHEN tmp[ITERATION_NUMBER-1] IS NULL
 23                                 THEN tmp[ITERATION_NUMBER]
 24                                 ELSE tmp[ITERATION_NUMBER] +
 25                                          Running_tot[cv()-1]
 26       END,
 27    tmp[ITERATION_NUMBER] = CASE WHEN Running_tot[ITERATION_NUMBER] < 20     /* input */
 28                                 THEN  0
 29                     END,
 30    rown[ITERATION_NUMBER] = CASE WHEN Running_tot[CV()-1] IS NULL
 31                                  THEN 1
 32                                  WHEN tmp[ITERATION_NUMBER-1] IS NULL
 33                                  THEN ITERATION_NUMBER
 34                             END,
 35    group_id[ITERATION_NUMBER] = MAX(rown)[ANY]
 36    )
 37  )
 38  WHERE id IS NOT NULL
 39  ORDER BY id
 40  /

        ID      VALUE RUNNING_TOT   GROUP_ID
---------- ---------- ----------- ----------
         1         10          10          1
         2          8          18          1
         3          5          23          1
         4         10          10          4
         5          7          17          4
         6          8          25          4
         7          4           4          7

7 rows selected.

Elapsed: 00:00:00.01
]]> By: JB318 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-220 JB318 Mon, 06 Aug 2007 16:22:15 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-220 Looks like my entry got lopped off somehow... <pre> SQL> WITH x AS ( 2 SELECT 1 id, 10 value FROM dual UNION ALL 3 SELECT 2 id, 8 value FROM dual UNION ALL 4 SELECT 3 id, 5 value FROM dual UNION ALL 5 SELECT 4 id, 10 value FROM dual UNION ALL 6 SELECT 5 id, 7 value FROM dual UNION ALL 7 SELECT 6 id, 8 value FROM dual UNION ALL 8 SELECT 7 id, 4 value FROM dual 9 ) 10 SELECT id,value, Running_tot, group_id 11 FROM (SELECT id, value, Running_tot, group_id 12 FROM (SELECT id, value, count(*) OVER( ) counter, 13 ROW_NUMBER() OVER (ORDER BY id) rn FROM x) 14 MODEL 15 DIMENSION BY (rn) 16 MEASURES (id,value, counter,CAST(NULL AS NUMBER) Running_tot, 17 value tmp, CAST(NULL AS NUMBER) group_id, CAST(NULL AS NUMBER) rown ) 18 RULES ITERATE(10000) 19 UNTIL (ITERATION_NUMBER>= counter[1]) 20 ( 21 Running_tot[ITERATION_NUMBER] 22 = CASE WHEN tmp[ITERATION_NUMBER-1] IS NULL 23 THEN tmp[ITERATION_NUMBER] 24 ELSE tmp[ITERATION_NUMBER] + 25 Running_tot[cv()-1] 26 END, 27 tmp[ITERATION_NUMBER] = CASE WHEN Running_tot[ITERATION_NUMBER] Looks like my entry got lopped off somehow…

SQL> WITH x AS (
  2          SELECT 1 id, 10 value FROM dual UNION ALL
  3          SELECT 2 id,  8 value FROM dual UNION ALL
  4          SELECT 3 id,  5 value FROM dual UNION ALL
  5          SELECT 4 id, 10 value FROM dual UNION ALL
  6          SELECT 5 id,  7 value FROM dual UNION ALL
  7          SELECT 6 id,  8 value FROM dual UNION ALL
  8          SELECT 7 id,  4 value FROM dual
  9  )
 10  SELECT id,value, Running_tot, group_id
 11    FROM (SELECT id, value, Running_tot, group_id
 12           FROM (SELECT id, value, count(*) OVER( ) counter,
 13                        ROW_NUMBER() OVER (ORDER BY id) rn FROM x)
 14   MODEL
 15   DIMENSION BY (rn)
 16   MEASURES (id,value, counter,CAST(NULL AS NUMBER) Running_tot,
 17             value tmp, CAST(NULL AS NUMBER) group_id, CAST(NULL AS NUMBER) rown )
 18   RULES ITERATE(10000)
 19   UNTIL (ITERATION_NUMBER>= counter[1])
 20   (
 21    Running_tot[ITERATION_NUMBER]
 22                          = CASE WHEN tmp[ITERATION_NUMBER-1] IS NULL
 23                                 THEN tmp[ITERATION_NUMBER]
 24                                 ELSE tmp[ITERATION_NUMBER] +
 25                                          Running_tot[cv()-1]
 26       END,
 27    tmp[ITERATION_NUMBER] = CASE WHEN Running_tot[ITERATION_NUMBER]
]]> By: JB318 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-219 JB318 Mon, 06 Aug 2007 16:21:16 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-219 That doesn't change the fact that you're not resetting the cumulative sum when you need to. <pre> SQL> set echo on SQL> @go1 SQL> WITH x AS ( 2 SELECT 1 id, 10 value FROM dual UNION ALL 3 SELECT 2 id, 8 value FROM dual UNION ALL 4 SELECT 3 id, 5 value FROM dual UNION ALL 5 SELECT 4 id, 10 value FROM dual UNION ALL 6 SELECT 5 id, 7 value FROM dual UNION ALL 7 SELECT 6 id, 8 value FROM dual UNION ALL 8 SELECT 7 id, 4 value FROM dual 9 ) 10 SELECT 11 id, 12 value, 13 SUM(value) OVER (PARTITION BY grp ORDER BY id) running_tot, 14 FIRST_VALUE(cnt) OVER (PARTITION BY grp ORDER BY id) group_id 15 FROM ( 16 SELECT 17 id, 18 value, 19 sum_cum, 20 NVL(TRUNC((sum_cum-value)/20),0) grp, 21 count(*) over(ORDER BY id) cnt 22 FROM ( 23 SELECT 24 id, 25 value, 26 SUM(value) over (ORDER BY id) sum_cum 27 FROM x 28 ) 29 ) 30 / ID VALUE RUNNING_TOT GROUP_ID ---------- ---------- ----------- ---------- 1 10 10 1 2 8 18 1 3 5 23 1 4 10 10 4 5 7 17 4 6 8 8 6 7 4 12 6 7 rows selected. Elapsed: 00:00:00.01 SQL> SQL> WITH x AS ( 2 SELECT 1 id, 10 value FROM dual UNION ALL 3 SELECT 2 id, 8 value FROM dual UNION ALL 4 SELECT 3 id, 5 value FROM dual UNION ALL 5 SELECT 4 id, 10 value FROM dual UNION ALL 6 SELECT 5 id, 7 value FROM dual UNION ALL 7 SELECT 6 id, 8 value FROM dual UNION ALL 8 SELECT 7 id, 4 value FROM dual 9 ) 10 SELECT id,value, Running_tot, group_id 11 FROM (SELECT id, value, Running_tot, group_id 12 FROM (SELECT id, value, count(*) OVER( ) counter, 13 ROW_NUMBER() OVER (ORDER BY id) rn FROM x) 14 MODEL 15 DIMENSION BY (rn) 16 MEASURES (id,value, counter,CAST(NULL AS NUMBER) Running_tot, 17 value tmp, CAST(NULL AS NUMBER) group_id, CAST(NULL AS NUMBER) rown ) 18 RULES ITERATE(10000) 19 UNTIL (ITERATION_NUMBER>= counter[1]) 20 ( 21 Running_tot[ITERATION_NUMBER] 22 = CASE WHEN tmp[ITERATION_NUMBER-1] IS NULL 23 THEN tmp[ITERATION_NUMBER] 24 ELSE tmp[ITERATION_NUMBER] + 25 Running_tot[cv()-1] 26 END, 27 tmp[ITERATION_NUMBER] = CASE WHEN Running_tot[ITERATION_NUMBER] That doesn’t change the fact that you’re not resetting the cumulative sum when you need to.

SQL> set echo on
SQL> @go1
SQL> WITH x AS (
  2          SELECT 1 id, 10 value FROM dual UNION ALL
  3          SELECT 2 id,  8 value FROM dual UNION ALL
  4          SELECT 3 id,  5 value FROM dual UNION ALL
  5          SELECT 4 id, 10 value FROM dual UNION ALL
  6          SELECT 5 id,  7 value FROM dual UNION ALL
  7          SELECT 6 id,  8 value FROM dual UNION ALL
  8          SELECT 7 id,  4 value FROM dual
  9  )
 10  SELECT
 11  id,
 12  value,
 13  SUM(value) OVER (PARTITION BY grp ORDER BY id) running_tot,
 14  FIRST_VALUE(cnt) OVER (PARTITION BY grp ORDER BY id) group_id
 15  FROM (
 16          SELECT
 17          id,
 18          value,
 19          sum_cum,
 20          NVL(TRUNC((sum_cum-value)/20),0) grp,
 21          count(*) over(ORDER BY id) cnt
 22          FROM (
 23                  SELECT
 24                  id,
 25                  value,
 26                  SUM(value) over (ORDER BY id) sum_cum
 27                  FROM x
 28          )
 29  )
 30  /

        ID      VALUE RUNNING_TOT   GROUP_ID
---------- ---------- ----------- ----------
         1         10          10          1
         2          8          18          1
         3          5          23          1
         4         10          10          4
         5          7          17          4
         6          8           8          6
         7          4          12          6

7 rows selected.

Elapsed: 00:00:00.01
SQL>
SQL> WITH x AS (
  2          SELECT 1 id, 10 value FROM dual UNION ALL
  3          SELECT 2 id,  8 value FROM dual UNION ALL
  4          SELECT 3 id,  5 value FROM dual UNION ALL
  5          SELECT 4 id, 10 value FROM dual UNION ALL
  6          SELECT 5 id,  7 value FROM dual UNION ALL
  7          SELECT 6 id,  8 value FROM dual UNION ALL
  8          SELECT 7 id,  4 value FROM dual
  9  )
 10  SELECT id,value, Running_tot, group_id
 11    FROM (SELECT id, value, Running_tot, group_id
 12           FROM (SELECT id, value, count(*) OVER( ) counter,
 13                        ROW_NUMBER() OVER (ORDER BY id) rn FROM x)
 14   MODEL
 15   DIMENSION BY (rn)
 16   MEASURES (id,value, counter,CAST(NULL AS NUMBER) Running_tot,
 17             value tmp, CAST(NULL AS NUMBER) group_id, CAST(NULL AS NUMBER) rown )
 18   RULES ITERATE(10000)
 19   UNTIL (ITERATION_NUMBER>= counter[1])
 20   (
 21    Running_tot[ITERATION_NUMBER]
 22                          = CASE WHEN tmp[ITERATION_NUMBER-1] IS NULL
 23                                 THEN tmp[ITERATION_NUMBER]
 24                                 ELSE tmp[ITERATION_NUMBER] +
 25                                          Running_tot[cv()-1]
 26       END,
 27    tmp[ITERATION_NUMBER] = CASE WHEN Running_tot[ITERATION_NUMBER]
]]> By: jan.stulrajter http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-218 jan.stulrajter Mon, 06 Aug 2007 15:44:59 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-218 And now? SELECT id,value, SUM(value) OVER(PARTITION BY grp ORDER BY id) running_tot, FIRST_VALUE (cnt)OVER(PARTITION BY grp ORDER BY id) group_id FROM(SELECT id,value,sum_cum, NVL(TRUNC(( sum_cum-value)/20),0) grp, count(*) over(ORDER BY id) cnt FROM(SELECT id,value, SUM(value) over(ORDER BY id) sum_cum FROM x)) And now?

SELECT
id,value,
SUM(value) OVER(PARTITION BY grp ORDER BY id) running_tot,
FIRST_VALUE (cnt)OVER(PARTITION BY grp ORDER BY id) group_id
FROM(SELECT id,value,sum_cum,
NVL(TRUNC(( sum_cum-value)/20),0) grp,
count(*) over(ORDER BY id) cnt
FROM(SELECT id,value,
SUM(value) over(ORDER BY id) sum_cum
FROM x))

]]> By: JB318 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-217 JB318 Mon, 06 Aug 2007 15:27:39 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-217 Alas, that's not the same since you don't restart the count when you create a new group. If you have a running total of 18 and your group size is 20, and the next row adds 5, 18 + 5 = 23 > 20 so you start a new group, but the running total is now 3, when it should be 0--you don't want to cut the subsequent group when there are only 17 more items. Alas, that’s not the same since you don’t restart the count when you create a new group. If you have a running total of 18 and your group size is 20, and the next row adds 5, 18 + 5 = 23 > 20 so you start a new group, but the running total is now 3, when it should be 0–you don’t want to cut the subsequent group when there are only 17 more items.

]]> By: jan.stulrajter http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-216 jan.stulrajter Mon, 06 Aug 2007 13:12:49 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-216 The same (I hope) using Analytics: SELECT id,value, SUM(value) OVER(PARTITION BY group_id ORDER BY id) running_tot, group_id FROM(SELECT id,value,sum_cum, NVL(TRUNC(( sum_cum-value)/:input),0) group_id FROM(SELECT id,value, SUM(value) over(ORDER BY id) sum_cum FROM x)) The same (I hope) using Analytics:

SELECT
id,value,
SUM(value) OVER(PARTITION BY group_id ORDER BY id) running_tot,
group_id
FROM(SELECT id,value,sum_cum,
NVL(TRUNC(( sum_cum-value)/:input),0) group_id
FROM(SELECT id,value,
SUM(value) over(ORDER BY id) sum_cum
FROM x))

]]> By: Frank Zhou http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-215 Frank Zhou Fri, 03 Aug 2007 18:31:17 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-215 Thanks for pointing out this special case ! The query has fixed. Thanks for pointing out this special case !
The query has fixed.

]]> By: JB318 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-214 JB318 Fri, 03 Aug 2007 16:15:51 +0000 http://oraqa.com/2007/08/02/how-to-divide-consecutive-rows-into-groups-based-on-the-value-of-the-smallest-running-total-in-sql/#comment-214 ...except I forgot to backport, it should look like: <pre> rown[ITERATION_NUMBER] = CASE WHEN Running_tot[CV()-1] IS NULL THEN 1 --WHEN Running_tot[CV()-1] > Running_tot[CV()] WHEN tmp[ITERATION_NUMBER-1] IS NULL THEN ITERATION_NUMBER END, </pre> You were using "tmp" both as the source of numbers to add, and as a flag of when to cut to the next group. I split that by using "value" directly, and "tmp" became "flag". …except I forgot to backport, it should look like:

rown[ITERATION_NUMBER] =
	CASE WHEN Running_tot[CV()-1] IS NULL
	THEN 1
	--WHEN Running_tot[CV()-1] > Running_tot[CV()]
	WHEN tmp[ITERATION_NUMBER-1] IS NULL
	THEN ITERATION_NUMBER
	END,

You were using “tmp” both as the source of numbers to add, and as a flag of when to cut to the next group. I split that by using “value” directly, and “tmp” became “flag”.

]]>