Counting blocks of continuous sequences in SQL - sql

Question

Let´s suppose this situation:
CAR TIME
A 1300
A 1301
A 1302
A 1315
A 1316
A 1317
A 1319
A 1320
B 1321
B 1322
I´d like to generate another column, enumerating each trip did by each car.
We consider there´s a new trip every time we get a discontinuity on TIME.
CAR TIME TRIP
A 1300 1
A 1301 1
A 1302 1
A 1315 2
A 1316 2
A 1317 2
A 1319 3
A 1320 3
B 1321 1
B 1322 1
Is there some SQL function to obtain this count ?
Thanks in advance.

Answer 1

You seems want cumulative approach :
select t.*, dense_rank() over (partition by car order by grp1) as trp
from (select t.*, sum(case when grp > 1 then 1 else 0 end) over (partition by car order by time) as grp1
from (select t.*, coalesce((time - lag(time) over (partition by car order by time)), 1) as grp
from table t
) t
) t;

Answer 2

I would use row_number() . . . and - to define the groups. Then, dense_rank():
select t.*,
dense_rank() over (partition by car order by time - seqnum) as trip
from (select t.*, row_number() over (partition by car order by time) as seqnum
from t
) t;
I cannot readily think of any alternative that uses fewer than 2 window functions -- or that would likely be faster using joins and group bys.

Answer 3

Here is how I'd solve this problem:
with grp as (
select row_number() over (partition by CAR order by TIME) rn, a.CAR, a.TIME
from test a
where not exists (select * from test b
where a.CAR=b.CAR
and to_date(b.TIME, 'YYYYmmDDHH24MI')+1/(24*60) = to_date(a.TIME, 'YYYYmmDDHH24MI'))
)
select t.CAR, t.TIME, (
select max(rn) from grp where t.CAR=grp.CAR and grp.TIME <= t.TIME
) as trip
from test t
the main idea is to select start time for each trip (this is done in CTE grp), then use row number as trip identifier
Sample fiddle http://sqlfiddle.com/#!4/6a327/10

Answer 4

Another approach:
SELECT t.car, t.time, MIN(t3.time)
FROM test t, test t3
WHERE NOT EXISTS (SELECT 1
FROM test t2
WHERE t2.car = t.car
AND t2.time = t.time - 1)
AND t3.car = t.car
AND t3.time >= t.time
AND NOT EXISTS (SELECT 1
FROM test t4
WHERE t4.car = t3.car
AND t4.time = t3.time + 1)
GROUP BY t.car, t.time
ORDER BY 1, 2;
The first not-exists finds all the rows that don't have a row for the same car in the previous minute - that is to say, those rows who begin a period for a car.
The later not-exists gets a set of rows that do not have a following row for the same car - i.e. rows that end a period. The max function finds the least of these (that also are filtered to be greater or equal to the start of the period in question.

Answer 5

Combining some of the other ideas, including trips crossing an hour boundary but without converting to a date (in case that is significantly slowing things down), and allowing for repeated times in the same trip:
-- CTE for sample data
with your_table (car, time) as (
select 'A', 201808151259 from dual -- extra row to go across hour
union all select 'A', 201808151300 from dual
union all select 'A', 201808151301 from dual
union all select 'A', 201808151302 from dual
union all select 'A', 201808151315 from dual
union all select 'A', 201808151316 from dual
union all select 'A', 201808151317 from dual
union all select 'A', 201808151319 from dual
union all select 'A', 201808151319 from dual -- extra row for duplicate time
union all select 'A', 201808151320 from dual
union all select 'B', 201808151321 from dual
union all select 'B', 201808151322 from dual
)
-- actual query
select car,
time,
dense_rank() over (partition by car order by trip_start) as trip
from (
select car,
time,
max(case when lag_time = time
or lag_time = time - case when mod(time, 100) = 00 then 41 else 1 end
then null else time end
) over (partition by car order by time) as trip_start
from (
select car,
time,
lag(time) over (partition by car order by time) as lag_time
from your_table
)
)
order by car, time;
which gets
CAR TIME TRIP
--- ------------ ------------
A 201808151259 1
A 201808151300 1
A 201808151301 1
A 201808151302 1
A 201808151315 2
A 201808151316 2
A 201808151317 2
A 201808151319 3
A 201808151319 3
A 201808151320 3
B 201808151321 1
B 201808151322 1
The innermost query just gets the original data and the previous time value for each row using lag().
The next query out finds the trip start by treating duplicate and adjacent times - including over an hour boundary, via the nested case expression - as null, and then finding the highest value so far, which ignores the just-generated nulls by default. All contiguous runs of times end up with the same trip-start time:
select car,
time,
max(case when lag_time = time
or lag_time = time - case when mod(time, 100) = 00 then 41 else 1 end
then null else time end
) over (partition by car order by time) as trip_start
from (
select car,
time,
lag(time) over (partition by car order by time) as lag_time
from your_table
)
order by car, time;
CAR TIME TRIP_START
--- ------------ ------------
A 201808151259 201808151259
A 201808151300 201808151259
A 201808151301 201808151259
A 201808151302 201808151259
A 201808151315 201808151315
A 201808151316 201808151315
A 201808151317 201808151315
A 201808151319 201808151319
A 201808151319 201808151319
A 201808151320 201808151319
B 201808151321 201808151321
B 201808151322 201808151321
The outermost query then uses dense_rank() to give the trips consecutive numbering based on their trip-start times.