Consulta para determinar las fechas de inicio y finalización en función de la superposición de tiempo

8

Dados los siguientes datos:

id      |   user_id |   started             |   closed              |   dead
-------------------------------------------------------------------------------------------
7714    |   238846  |   2015-01-27 15:14:50 |   2015-02-02 14:14:13 |   NULL
7882    |   238846  |   2015-01-28 13:25:58 |   NULL                |   2015-05-15 12:16:07
13190   |   259140  |   2015-03-17 10:11:44 |   NULL                |   2015-03-18 07:31:57
13192   |   259140  |   2015-03-17 10:12:17 |   NULL                |   2015-03-18 11:46:46
13194   |   259140  |   2015-03-17 10:12:53 |   NULL                |   2015-03-18 11:46:36
14020   |   259140  |   2015-03-23 14:32:16 |   2015-03-24 15:57:32 |   NULL
17124   |   242650  |   2015-04-16 16:19:08 |   2015-04-16 16:21:06 |   NULL
19690   |   238846  |   2015-05-15 13:17:31 |   NULL                |   2015-05-27 13:56:43
20038   |   242650  |   2015-05-19 15:38:17 |   NULL                |   NULL
20040   |   242650  |   2015-05-19 15:39:58 |   NULL                |   2015-05-21 12:01:02
20302   |   242650  |   2015-05-21 13:09:06 |   NULL                |   NULL
20304   |   242650  |   2015-05-21 13:09:54 |   NULL                |   NULL
20306   |   242650  |   2015-05-21 13:10:19 |   NULL                |   NULL
20308   |   242650  |   2015-05-21 13:12:20 |   NULL                |   NULL
21202   |   238846  |   2015-05-29 16:47:29 |   NULL                |   NULL
21204   |   238846  |   2015-05-29 16:47:56 |   NULL                |   NULL
21208   |   238846  |   2015-05-29 17:05:15 |   NULL                |   NULL
21210   |   238846  |   2015-05-29 17:05:55 |   NULL                |   NULL
21918   |   242650  |   2015-06-04 17:04:29 |   NULL                |   2015-06-12 15:47:23

Necesito crear un conjunto de datos que cumpla con las siguientes reglas:

  1. Los grupos se definen primero por, por user_idlo que deberíamos comparar solo registros de la mismauser_id
  2. Todos los registros que comenzaron al menos dentro de los 15 días de cuando se inició cualquier otro registro, cerrado o muerto, deben contarse como grupo.
  3. De cada grupo, el final debe calcularse como el primer registro cerrado o todos los registros tienen un valor de muertos y tomamos la fecha más grande de la columna de muertos.
  4. Si un registro no comenzó dentro de los 15 días posteriores al inicio o al final de otro grupo, entonces comienza una nueva agrupación.

Tentativamente, creo que mis datos deberían verse así:

user_id | comenzó | final
-------------------------------------------------- ----
238846 | 2015-01-27 15:14:50 | 2015-02-02 14:14:13
259140 | 2015-03-23 ​​14:32:16 | 2015-03-24 15:57:32
242650 | 2015-04-16 16:19:08 | 2015-04-16 16:21:06
242650 | 2015-05-21 13:09:06 | NULO
238846 | 2015-05-15 13:17:31 | NULO

¿Alguien puede proporcionar alguna orientación sobre cómo crear una consulta para cumplir con estas condiciones?

Aquí hay un enlace a las declaraciones DDL y DML para los datos presentados en esta pregunta.

Alternativamente, podríamos omitir las reglas # 2 y # 4 y más simplemente declarar que solo se deben incluir los registros que se superponen entre sí. La regla más importante es que, en un conjunto dado, si hay una fecha de cierre, se convierte en el final del conjunto y no en la fecha límite más grande.

mysql 
— Noah Goodrich
fuente
Esto sería más fácil con un cambio de esquema. No hay necesidad de las dos columnas, cerradas y muertas. Simplemente tenga una columna "finalizada" y luego una razón para la finalización.
— Andrew Brennan
Sus primeros 3 ejemplos se pueden codificar como "Si un id está 'cerrado', entonces es un grupo en sí mismo. Dado que eso no parece resaltar todas sus reglas, agregue más ejemplos.
— Rick James

Respuestas:

3

Debido a la falta de claridad en la pregunta, se me ocurrieron cuatro soluciones diferentes. Las soluciones difieren en:

  1. Ya sea que estés en "cascada" según la respuesta de Chris
  2. Cuando tiene una fecha cerrada, si usa la fecha más temprana para ese grupo o la fecha de inicio para el registro que está cerrado.

Tenga en cuenta que esto se hace en SQL Server, no en MySQL. Aparte de algunos cambios de sintaxis muy menores, debería funcionar igual.

Configuración común y datos de muestra para los cuatro métodos

CREATE TABLE #example 
(
    id int NOT NULL DEFAULT '0',
    borrower_id int NOT NULL,
    started datetime NULL DEFAULT NULL,
    closed datetime NULL DEFAULT NULL,
    dead datetime NULL DEFAULT '0000-00-00 00:00:00'
);

CREATE TABLE #result 
(   
    borrower_id int NOT NULL DEFAULT '0',    
    started datetime NULL DEFAULT NULL,    
    ended datetime NULL DEFAULT NULL 
);    

INSERT INTO #example 
    (id, borrower_id, started, closed, dead) 
VALUES 
    (7714,238846,'2015-01-27 15:14:50','2015-02-02 14:14:13',NULL), 
    (7882,238846,'2015-01-28 13:25:58',NULL,'2015-05-15 12:16:07'), 
    (13190,259140,'2015-03-17 10:11:44',NULL,'2015-03-18 07:31:57'), 
    (13192,259140,'2015-03-17 10:12:17',NULL,'2015-03-18 11:46:46'), 
    (13194,259140,'2015-03-17 10:12:53',NULL,'2015-03-18 11:46:36'), 
    (14020,259140,'2015-03-23 14:32:16','2015-03-24 15:57:32',NULL), 
    (17124,242650,'2015-04-16 16:19:08','2015-04-16 16:21:06',NULL), 
    (19690,238846,'2015-05-15 13:17:31',NULL,'2015-05-27 13:56:43'), 
    (20038,242650,'2015-05-19 15:38:17',NULL,NULL), 
    (20040,242650,'2015-05-19 15:39:58',NULL,'2015-05-21 12:01:02'), 
    (20302,242650,'2015-05-21 13:09:06',NULL,NULL), 
    (20304,242650,'2015-05-21 13:09:54',NULL,NULL), 
    (20306,242650,'2015-05-21 13:10:19',NULL,NULL), 
    (20308,242650,'2015-05-21 13:12:20',NULL,NULL), 
    (21202,238846,'2015-05-29 16:47:29',NULL,NULL), 
    (21204,238846,'2015-05-29 16:47:56',NULL,NULL), 
    (21208,238846,'2015-05-29 17:05:15',NULL,NULL), 
    (21210,238846,'2015-05-29 17:05:55',NULL,NULL), 
    (21918,242650,'2015-06-04 17:04:29',NULL,'2015-06-12 15:47:23');

1. EN CASCADA - UTILIZANDO la solución de REGISTRO CERRADO

Esta es la solución que creo que el autor de la pregunta está buscando y coincide con sus resultados.

select *
into #temp1
from #example

while (select count(1) from #temp1)>0
begin
    --Grab only one user's records and place into a temp table to work with
    declare @curUser int
    set @curUser=(select min(borrower_id) from #temp1)

    select * 
    into #temp2
    from #temp1 t1
    where t1.borrower_id=@curUser

    while(select count(1) from #temp2)>0
    begin
        --Grab earliest start date and use as basis for 15 day window (#2 rule)
        --Use the record as basis for rules 3 and 4
        declare @minTime datetime
        set @minTime=(select min(started) from #temp2)

        declare @maxTime datetime
        set @maxTime=@minTime

        declare @curId int
        set @curId=(select min(id) from #temp2 where started=@minTime)

        select * 
        into #temp3
        from #temp2 t2
        where t2.id=@curId

        --Remove earliest record from pool of potential records to check rules against
        delete 
        from #temp2 
        where id=@curId

        --Insert all records within 15 days of start date, then remove record from pool
        while (select count(1) 
                from #temp2 t2 
                where t2.started<=DATEADD(day,15,@maxTime) 
                    or t2.closed<=DATEADD(day,15,@maxTime) 
                    or t2.dead<=DATEADD(day,15,@maxTime)  )>0
        begin
            insert into #temp3
            select *
            from #temp2 t2
            where t2.started<=DATEADD(day,15,@maxTime)  or t2.closed<=DATEADD(day,15,@maxTime)  or t2.dead<=DATEADD(day,15,@maxTime) 

            delete
            from #temp2
            where started<=DATEADD(day,15,@maxTime)  or closed<=DATEADD(day,15,@maxTime)  or dead<=DATEADD(day,15,@maxTime) 

            --set new max time from any column
            if (select max(started) from #temp3)>@maxTime
                set @maxTime=(select max(started) from #temp3)
            if (select max(closed) from #temp3)>@maxTime
                set @maxTime=(select max(started) from #temp3)
            if (select max(dead) from #temp3)>@maxTime
                set @maxTime=(select max(started) from #temp3)

        end

        --Calculate end time according to rule #3
        declare @end datetime 
        set @end = null
        set @end=(select min(closed) from #temp3)

        if @end is not null
        begin
            set @minTime=(select started from #temp3 where closed=@end)
        end

        if @end is null
        begin
            if(select count(1) from #temp3 where dead is null)=0
            set @end= (select max(dead) from #temp3)
        end

        insert into #result (borrower_id,started,ended)
        values (@curUser,@minTime,@end)

        drop table #temp3
    end

    --Done with the one user, remove him from temp table and iterate thru to the next user
    delete  
    from #temp1 
    where borrower_id=@curUser    

    drop table #temp2

end

drop table #temp1

drop table #example

select * from #result order by started

drop table #result

2. NO EN CASCADA - UTILIZANDO la solución de REGISTRO CERRADO

Comience calculado por la primera fecha de cierre cuando esté disponible, luego por la fecha de inicio más temprana.

select *
into #temp1
from #example

while (select count(1) from #temp1)>0
begin
    --Grab only one user's records and place into a temp table to work with
    declare @curUser int
    set @curUser=(select min(borrower_id) from #temp1)

    select * 
    into #temp2
    from #temp1 t1
    where t1.borrower_id=@curUser

    while(select count(1) from #temp2)>0
    begin
        --Grab earliest start date and use as basis for 15 day window (#2 rule)
        --Use the record as basis for rules 3 and 4
        declare @minTime datetime
        set @minTime=(select min(started) from #temp2)

        declare @curId int
        set @curId=(select min(id) from #temp2 where started=@minTime)

        select * 
        into #temp3
        from #temp2 t2
        where t2.id=@curId

        --Remove earliest record from pool of potential records to check rules against
        delete 
        from #temp2 
        where id=@curId

        --Insert all records within 15 days of start date, then remove record from pool
        insert into #temp3
        select *
        from #temp2 t2
        where t2.started<=DATEADD(day,15,@minTime)

        delete
        from #temp2
        where started<=DATEADD(day,15,@minTime)

        --Insert all records within 15 days of closed, then remove record from pool
        insert into #temp3
        select *
        from #temp2 t2
        where t2.closed<=DATEADD(day,15,@minTime)

        delete
        from #temp2
        where closed<=DATEADD(day,15,@minTime)

        --Insert all records within 15 days of dead, then remove record from pool
        insert into #temp3
        select *
        from #temp2 t2
        where t2.dead<=DATEADD(day,15,@minTime)

        delete
        from #temp2
        where dead<=DATEADD(day,15,@minTime)

        --Calculate end time according to rule #3
        declare @end datetime 
        set @end = null
        set @end=(select min(closed) from #temp3)

        if @end is not null
        begin
            set @minTime=(select started from #temp3 where closed=@end)
        end

        if @end is null
        begin
            if(select count(1) from #temp3 where dead is null)=0
            set @end= (select max(dead) from #temp3)
        end

        insert into #result (borrower_id,started,ended)
        values (@curUser,@minTime,@end)

        drop table #temp3
    end

    --Done with the one user, remove him from temp table and iterate thru to the next user
    delete  
    from #temp1 
    where borrower_id=@curUser


    drop table #temp2

end

drop table #temp1

drop table #example

select * from #result

drop table #result

3. NO CASCADING - UTILIZANDO la solución de FECHA ANTERIOR

Inicio calculado solo por la fecha más temprana.

select *
into #temp1
from #example

while (select count(1) from #temp1)>0
begin
    --Grab only one user's records and place into a temp table to work with
    declare @curUser int
    set @curUser=(select min(borrower_id) from #temp1)

    select * 
    into #temp2
    from #temp1 t1
    where t1.borrower_id=@curUser

    while(select count(1) from #temp2)>0
    begin
        --Grab earliest start date and use as basis for 15 day window (#2 rule)
        --Use the record as basis for rules 3 and 4
        declare @minTime datetime
        set @minTime=(select min(started) from #temp2)

        declare @curId int
        set @curId=(select min(id) from #temp2 where started=@minTime)

        select * 
        into #temp3
        from #temp2 t2
        where t2.id=@curId

        --Remove earliest record from pool of potential records to check rules against
        delete 
        from #temp2 
        where id=@curId

        --Insert all records within 15 days of start date, then remove record from pool
        insert into #temp3
        select *
        from #temp2 t2
        where t2.started<=DATEADD(day,15,@minTime) or t2.closed<=DATEADD(day,15,@minTime) or t2.dead<=DATEADD(day,15,@minTime)

        delete
        from #temp2
        where started<=DATEADD(day,15,@minTime) or closed<=DATEADD(day,15,@minTime) or dead<=DATEADD(day,15,@minTime)

        --Calculate end time according to rule #3
        declare @end datetime 
        set @end = null

        set @end=(select min(closed) from #temp3)

        if @end is null
        begin
            if(select count(1) from #temp3 where dead is null)=0
            set @end= (select max(dead) from #temp3)
        end

        insert into #result (borrower_id,started,ended)
        values (@curUser,@minTime,@end)

        drop table #temp3
    end

    --Done with the one user, remove him from temp table and itterate thru to the next user
    delete  
    from #temp1 
    where borrower_id=@curUser    

    drop table #temp2

end

drop table #temp1

drop table #example

select * from #result

drop table #result

4. EN CASCADA: USO DE LA FECHA ANTERIOR solución

Inicio calculado solo por la fecha más temprana.

select *
into #temp1
from #example

while (select count(1) from #temp1)>0
begin
--Grab only one user's records and place into a temp table to work with
declare @curUser int
set @curUser=(select min(borrower_id) from #temp1)

select * 
into #temp2
from #temp1 t1
where t1.borrower_id=@curUser

while(select count(1) from #temp2)>0
begin
    --Grab earliest start date and use as basis for 15 day window (#2 rule)
    --Use the record as basis for rules 3 and 4
        declare @minTime datetime
    set @minTime=(select min(started) from #temp2)


    declare @maxTime datetime
    set @maxTime=@minTime

    declare @curId int
    set @curId=(select min(id) from #temp2 where started=@minTime)

    select * 
    into #temp3
    from #temp2 t2
    where t2.id=@curId

    --Remove earliest record from pool of potential records to check rules against
    delete 
    from #temp2 
    where id=@curId

    --Insert all records within 15 days of start date, then remove record from pool
    while (select count(1) 
            from #temp2 t2 
            where t2.started<=DATEADD(day,15,@maxTime) 
                or t2.closed<=DATEADD(day,15,@maxTime) 
                or t2.dead<=DATEADD(day,15,@maxTime)  )>0
    begin
        insert into #temp3
        select *
        from #temp2 t2
        where t2.started<=DATEADD(day,15,@maxTime)  or t2.closed<=DATEADD(day,15,@maxTime)  or t2.dead<=DATEADD(day,15,@maxTime) 

        delete
        from #temp2
        where started<=DATEADD(day,15,@maxTime)  or closed<=DATEADD(day,15,@maxTime)  or dead<=DATEADD(day,15,@maxTime) 

        --set new max time from any column
        if (select max(started) from #temp3)>@maxTime
            set @maxTime=(select max(started) from #temp3)
        if (select max(closed) from #temp3)>@maxTime
            set @maxTime=(select max(started) from #temp3)
        if (select max(dead) from #temp3)>@maxTime
            set @maxTime=(select max(started) from #temp3)

    end

    --Calculate end time according to rule #3
    declare @end datetime 
    set @end = null

    set @end=(select min(closed) from #temp3)

    if @end is null
    begin
        if(select count(1) from #temp3 where dead is null)=0
        set @end= (select max(dead) from #temp3)
    end

    insert into #result (borrower_id,started,ended)
    values (@curUser,@minTime,@end)

    drop table #temp3
end

--Done with the one user, remove him from temp table and iterate thru to the next user
delete  
from #temp1 
where borrower_id=@curUser

drop table #temp2

end

drop table #temp1

drop table #example

select * from #result order by started

drop table #result
— Anthony Genovese
fuente
-2

Me preocupa que no tengamos una idea clara de cómo se define un grupo. Solo digo esto porque, dependiendo de algunas condiciones no establecidas, las fechas anteriores formarán un solo grupo gigante o 3 grupos en los que un grupo dominará el conjunto.

¿Faltan condiciones de agrupación?

1) ¿Esta regla de 15 días en cascada? Si un registro Ycomienza 10 días después de otro registro X, y luego hay otro registro Ziniciado 10 días después de eso, ¿esto forma un grupo de tres registros X,Y,Z, o dos grupos que contienen cada uno dos registros X,Yy Y,Z? Supuse que las reglas de 15 días caen en cascada para formar grupos más grandes.

2) ¿Las fechas son inclusivas? Por ejemplo, si un registro tiene una fecha de inicio y luego una fecha límite muchos meses después, ¿se fusionan todos los días dentro de ese rango en el grupo? Trato ambas posibilidades en mi análisis rápido a continuación.

Agrupaciones potenciales

Entonces, si comenzamos con id 7714, vemos que la fecha de inicio es 1/27. Claramente, la siguiente entrada que 7882comienza el 1/28 cae en este grupo. Sin embargo 7882, tenga en cuenta que termina el 15/5, por lo que todo lo que comienza dentro de los 15 días del 15/05 debe agregarse al grupo.

Por lo tanto, a 19690través de 21210obtener agregado al grupo, que a través de la cascada conduce a 21918ser agregado posteriormente al grupo. La cascada ha consumido casi todas las entradas en el conjunto. Llama a esto GROUP A.

Sin embargo, si la agrupación también incluye la fecha, todas las entradas de 13190hasta 17124también deben pertenecer GROUP A, y ahora todos los identificadores están en un solo grupo.

Si las fechas de GROUP Ano están incluidos, pero en realidad se adhieren estrictamente a la '15 días después' regla con cascada, entonces en vez tendría un segundo grupo compuesto por 13190a través 14020, y un tercer grupo con una sola entrada, 17124.

Básicamente, mi pregunta es, ¿alguno de estos coincide con su grupo previsto o hay alguna otra información que nos falta en la definición del grupo? Lamento una respuesta tan larga, pero no parece que el resultado solicitado provisionalmente cumpla con su definición de agrupación.

Con aclaraciones, estoy seguro de que podemos solucionar este problema.

— Chris
fuente
¿Qué pasa si me deshago de la regla de los 15 días por completo? ¿Eso simplificaría el problema?
— Noah Goodrich
2
Además, creo que te perdiste un poco sobre dar prioridad a la primera fecha cerrada sobre la última fecha límite. Como resultado, para la primera agrupación que comienza el 1/27, la fecha de cierre del 2/2 se convierte en el final del grupo y no en el 5/15.
— Noah Goodrich
Sí, tienes razón, interpreté mal lo que dijiste sobre el primer cerrado / último muerto ... Lo siento, estaba trabajando en esto anoche alrededor de las 12:30 de la noche, hora del Pacífico, así que puede que haya estado un poco soñoliento. :) Además, la agrupación adicional por datos de usuario puede ayudar, creo. Lo pensaré un poco más y trataré de responderte.
— Chris
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.