Styjun

I have to group continuous timeslots together:

Example:

DECLARE @TEST as Table (ID int, tFrom datetime, tUntil dateTime)
insert into @TEST Values (1,'2019-1-1 12:00', '2019-1-1 13:00')
insert into @TEST Values (1,'2019-1-1 13:00', '2019-1-1 14:00')
insert into @TEST Values (1,'2019-1-1 14:00', '2019-1-1 16:00')
insert into @TEST Values (1,'2019-1-1 18:00', '2019-1-1 19:00')
insert into @TEST Values (1,'2019-1-1 19:00', '2019-1-1 20:00')
insert into @TEST Values (1,'2019-1-1 20:00', '2019-1-1 21:00')
insert into @TEST Values (1,'2019-1-1 22:00', '2019-1-1 23:00')
insert into @TEST Values (2,'2019-1-1 12:00', '2019-1-1 13:00')
insert into @TEST Values (2,'2019-1-1 13:00', '2019-1-1 14:00')
insert into @TEST Values (2,'2019-1-1 14:00', '2019-1-1 16:00')
insert into @TEST Values (2,'2019-1-1 18:00', '2019-1-1 19:00')
insert into @TEST Values (2,'2019-1-1 19:00', '2019-1-1 20:00')
insert into @TEST Values (2,'2019-1-1 20:00', '2019-1-1 21:00')
insert into @TEST Values (2,'2019-1-1 22:00', '2019-1-1 23:00')

Expected result:

1; 2019-1-1 12:00; 2019-1-1 16:00
1; 2019-1-1 18:00; 2019-1-1 21:00
1; 2019-1-1 22:00; 2019-1-1 23:00
2; 2019-1-1 12:00; 2019-1-1 16:00
2; 2019-1-1 18:00; 2019-1-1 21:00
2; 2019-1-1 22:00; 2019-1-1 23:00

This is a classing gaps-and-islands problem.
The key here is how to identify the groups.

If the difference between tFrom and tUntil is always exactly one hour, you can ignore the tUntil and work only based on the differences between tFrom of different records.

Use a common table expression to identify the groups, and then select min(tFrom) and max(tUntil) from it, grouped by id and group.

What you do is calculate the hours difference between the tFrom and some fixed date, and you subtract that value from row_number ordered by tFrom (and partitioned by id in this case).

This means that consecutive values of tFrom will get the same group key (consecutive here means by the hour in this case):

WITH CTE AS
(
 SELECT ID, 
 tFrom, 
 tUntil,
 ROW_NUMBER() OVER(PARTITION BY id ORDER BY tFrom) - 
 DATEDIFF(HOUR, '2019-01-01', tFrom) As grp
 FROM @Test
)

SELECT ID, 
 MIN(tFrom) As tFrom, 
 MAX(tUntil) As tUntil 
FROM CTE
GROUP BY ID, grp
ORDER BY Id, tFrom

If the difference between tFrom and tUntill is not fixed, than it's going to be more cumbersome to identify the groups.

I came up with a solution involving three common table expressions - the first is to get the datediff between the current row's tUntill and the next row's tFrom, then calculate a group divider based on previous row's difference, and then calculate the group id based on sums of the dividers:

WITH CTE1 AS
(
 SELECT ID, 
 tFrom, 
 tUntil,
 DATEDIFF(HOUR, tUntil, LEAD(tFrom) OVER(PARTITION BY id ORDER BY tFrom)) As DiffNext
 FROM @Test
), CTE2 AS
(
 SELECT ID, 
 tFrom, 
 tUntil,
 ISNULL(SIGN(LAG(DiffNext) OVER(PARTITION BY id ORDER BY tFrom)), 1) AS GroupDivider
 FROM CTE1
), CTE3 AS
(
 SELECT ID, 
 tFrom, 
 tUntil,
 SUM(GroupDivider) OVER(PARTITION BY id ORDER BY tFrom) As GroupId
 FROM CTE2
)

SELECT ID, 
 MIN(tFrom) As tFrom, 
 MAX(tUntil) As tUntil
FROM CTE3
GROUP BY ID, GroupId
ORDER BY ID, tFrom

Good day,

In order to have a flexible solution which cover overlap in the ranges of the time, there are several solutions which we can use. "Gaps & Islands" approach is not the best (from the performance point of view), but it will work, and there are worse options as well (like using loop/cursor). Since "Gaps & Islands" was the phrase that mentioned in the comments and in the solution which was discuss in the comments, l will first show this solution in short.

The solution using the "Gaps & Islands" approach is based on two steps (one query which use CTE). First, you split the ranges into "points in time". Next using "numbers" table or better in this case a "Times" table, you can get the final result SET by finding the gaps between the points, which is classic "Gaps & Islands" problem.

I HIGHLY recommend to follow the post, which I published, and follow it from start to end! There are limitations and disadvantages for this approach, which you must understand. Moreover, the post present the "way of thinking" and how we solve problems like this one step-by-step.

In the post I start with the simplest case of ranges of integers, for example 2-4, 6-8, 8-10, 13-14 which should be grouped into 2-4, 6-10, 13-14.

Next I move to explain issue related to the resolution of space between the ranges, and I present a solution for Ranges of Decimal numbers, which cover the issue.

Finally, using the solution which I presented in detail for INTEGERS, I presented a solution for "Grouping continuous time-slots together", which was the original question in the forum.

Note! The solution which presented here is probably the one which I recommend to use in production. In my next post I published a totally different approach using my personal trick, which can improve performance dramatically.

In short, for the sake of the discussion I will create a Times table (you can use Numbers table directly if you really want). Notice that I create the Times table using a Numbers table.

DROP TABLE IF EXISTS Times
GO
SELECT DT = DATEADD(MINUTE, N*10, '2010-01-01')
 INTO Times
FROM Numbers
GO
CREATE CLUSTERED INDEX IX_DT ON Times(DT)
GO
SELECT TOP 1000 DT from Times
GO

and using this table we can solve the issue

;With MyCTE01 as (
 SELECT DISTINCT ID, DT
 FROM TEST t
 INNER JOIN Times dt ON DT between tFrom and tUntil
)
,MyCTE02 as(
 SELECT ID, DT,
 MyGroup =
 DATEDIFF(MINUTE,
 DATEADD(MINUTE, 10 * ROW_NUMBER()OVER(PARTITION BY ID ORDER BY ID,DT),0),
 DT
 )
 from MyCTE01
 --order by ID,DT
)
SELECT ID, MIN(DT) tFrom, MAX(DT) tUntil
FROM MyCTE02
GROUP BY ID, MyGroup
ORDER BY ID, tFrom
GO

Note! I highly recommend to check the second post (Part 2) before choosing the solution that fit you in production.

I hope that this cover the discussion and that it was helpful