All geek questions in one place

If the difference between the two sequences is greater than 30, subtract the larger sequence

It is difficult for me to make a request that receives a lot of numbers, a sequence of numbers, and if the difference between the two of them is more than 30, then the sequence is reset from this number. So, I have the following table, in which there is another column, different from the number one, which should be kept intact.

+----+--------+--------+
| Id | Number | Status |
+----+--------+--------+
|  1 |      1 | OK     |
|  2 |      1 | Failed |
|  3 |      2 | Failed |
|  4 |      3 | OK     |
|  5 |      4 | OK     |
|  6 |     36 | Failed |
|  7 |     39 | OK     |
|  8 |     47 | OK     |
|  9 |     80 | Failed |
| 10 |    110 | Failed |
| 11 |    111 | OK     |
| 12 |    150 | Failed |
| 13 |    165 | OK     |
+----+--------+--------+

He must turn it into this:

+----+--------+--------+
| Id | Number | Status |
+----+--------+--------+
|  1 |      1 | OK     |
|  2 |      1 | Failed |
|  3 |      2 | Failed |
|  4 |      3 | OK     |
|  5 |      4 | OK     |
|  6 |      1 | Failed |
|  7 |      4 | OK     |
|  8 |     12 | OK     |
|  9 |      1 | Failed |
| 10 |      1 | Failed |
| 11 |      2 | OK     |
| 12 |      1 | Failed |
| 13 |     16 | OK     |
+----+--------+--------+

Thank you for your attention, I will be available to resolve any doubts about my problem! :)

EDIT: An example of this table is here: http://sqlfiddle.com/#!6/ded5af

+4
source share
5 answers

In this case:

declare @data table (id int identity, Number int, Status varchar(20));
insert @data(number, status) values
     ( 1,'OK')
    ,( 1,'Failed')
    ,( 2,'Failed')
    ,( 3,'OK')
    ,( 4,'OK')
    ,( 4,'OK')      -- to be deleted, ensures IDs are not sequential
    ,(36,'Failed')  -- to be deleted, ensures IDs are not sequential
    ,(36,'Failed')
    ,(39,'OK')
    ,(47,'OK')
    ,(80,'Failed')
,(110,'Failed')
,(111,'OK')
,(150,'Failed')
,(165,'OK')
;

delete @data where id between 6 and 7;

This SQL:

with renumbered as (
    select rn = row_number() over (order by id), data.*
    from @data data
),
paired as (
    select
        this.*,
        startNewGroup = case when this.number - prev.number >= 30 
                               or prev.id is null then 1 else 0 end
    from renumbered this
    left join renumbered prev on prev.rn = this.rn -1
),
groups as (
    select Id,Number, GroupNo = Number from paired where startNewGroup = 1
)
select
     Id
    ,Number = 1 + Number - (
                    select top 1 GroupNo 
                    from groups where groups.id <= paired.id 
                    order by GroupNo desc)
    ,status
from paired
;

:

Id          Number      status
----------- ----------- --------------------
1           1           OK
2           1           Failed
3           2           Failed
4           3           OK
5           4           OK
8           1           Failed
9           4           OK
10          12          OK
11          1           Failed
12          1           Failed
13          2           OK
14          1           Failed
15          16          OK

: LAG() SQL :

with renumbered as (
    select
         data.*
        ,gap = number - lag(number, 1) over (order by number)
    from @data data
),
paired as (
    select
        *,
        startNewGroup = case when gap >= 30 or gap is null then 1 else 0 end
    from renumbered 
),
groups as (
    select Id,Number, GroupNo = Number from paired where startNewGroup = 1
)
select
     Id
    ,Number = 1 + Number - ( select top 1 GroupNo 
                             from groups 
                             where groups.id <= paired.id 
                             order by GroupNo desc
                           )
    ,status
from paired
;
+4

, ,

with gapped as 
(   select id, number, gap = number - lag(number, 1) over (order by id)
    from @data data
),
select Id, status
       ReNumber = Number + 1 - isnull( (select top 1 gapped.Number 
                                          from gapped 
                                         where gapped.id <= data.id 
                                           and gap >= 30 
                                         order by gapped.id desc), 1)  
from @data data;
+2

Pieter Geerkens . :

with renumbered as (
    select data.*, gap = number - lag(number, 1) over (order by number)
    from @data data
),
paired as (
    select *
    from renumbered 
    where gap >= 30 or gap is null
)

select Id, Number = 1 + Number - (select top 1 Number 
                             from paired 
                             where paired.id <= renumbered.id 
                             order by Number desc)
    , status
from renumbered;

, .

+1

cte row_number ID, cte, ID

WITH cte AS 
(   SELECT 
        Id, [Number], [Status],
        0 AS Diff,
        [Number] AS [NewNumber]
    FROM
        Table1
    WHERE Id = 1
    UNION ALL 
    SELECT 
        t1.Id, t1.[Number], t1.[Status],
        CASE WHEN t1.[Number] - cte.[Number] >= 30 THEN t1.Number - 1 ELSE Diff END,
        CASE WHEN t1.[Number] - cte.[Number] >= 30 THEN 1 ELSE t1.[Number] - Diff END
    FROM Table1 t1
    JOIN cte ON cte.Id + 1 = t1.Id
)
SELECT Id, [NewNumber], [Status] 
FROM cte

SQL Fiddle

SQL , , ID .

SQL Fiddle 2

, sql

--Order table to make sure there is a sequence to follow
WITH OrderedSequence AS
(
    SELECT 
        ROW_NUMBER() OVER (ORDER BY Id) RnId,
        Id,
        [Number],
        [Status]
    FROM 
        Sequence
),
RecursiveCte AS 
(   SELECT 
        Id, [Number], [Status],
        0 AS Diff,
        [Number] AS [NewNumber],
        RnId
    FROM
        OrderedSequence
    WHERE Id = 1
    UNION ALL 
    SELECT 
        t1.Id, t1.[Number], t1.[Status],
        CASE WHEN t1.[Number] - cte.[Number] >= 30 THEN t1.Number - 1 ELSE Diff END,
        CASE WHEN t1.[Number] - cte.[Number] >= 30 THEN 1 ELSE t1.[Number] - Diff END,
        t1.RnId      
    FROM OrderedSequence t1
    JOIN RecursiveCte cte ON cte.RnId + 1 = t1.RnId
)
SELECT Id, [NewNumber], [Status] 
FROM RecursiveCte
0

I tried to optimize the queries here, since it took 1h20m to process my data. I had it until 30 years after some further research.

WITH AuxTable AS 
(   SELECT
        id, 
        number,
        status,

        relevantId = CASE WHEN 
            number = 1 OR 
            ((number - LAG(number, 1) OVER (ORDER BY id)) > 29)
        THEN id
        ELSE NULL
        END,

        deduct = CASE WHEN 
            ((number - LAG(number, 1) OVER (ORDER BY id)) > 29)
        THEN number - 1
        ELSE 0
        END

    FROM @data data
)
,AuxTable2 AS
(
    SELECT 
        id, 
        number,
        status,
        AT.deduct, 

        MAX(AT.relevantId) OVER (ORDER BY AT.id ROWS UNBOUNDED PRECEDING ) AS lastRelevantId

    FROM AuxTable AT
)

    SELECT 
        id, 
        number,
        status,   

        number - MAX(deduct) OVER(PARTITION BY lastRelevantId ORDER BY id ROWS UNBOUNDED PRECEDING ) AS ReNumber,

    FROM AuxTable2

I think it works faster, but it is not shorter.

0
source

Source: https://habr.com/ru/post/1618649/

More articles:


All Articles