เลือกจุดเริ่มต้นและจุดสิ้นสุดของช่วงต่อเนื่องหลายช่วงอย่างมีประสิทธิภาพในแบบสอบถาม Postgresql

ฉันมีข้อมูลประมาณหนึ่งพันล้านแถวในตารางที่มีชื่อและจำนวนเต็มในช่วง 1-288 สำหรับชื่อที่กำหนดintทุกตัวจะไม่ซ้ำกันและไม่ใช่จำนวนเต็มเท่าที่เป็นไปได้ทั้งหมดในช่วงนั้น - ดังนั้นจึงมีช่องว่าง

แบบสอบถามนี้สร้างกรณีตัวอย่าง:

--what I have:
SELECT *
FROM ( VALUES ('foo', 2),
              ('foo', 3),
              ('foo', 4),
              ('foo', 10),
              ('foo', 11),
              ('foo', 13),
              ('bar', 1),
              ('bar', 2),
              ('bar', 3)
     ) AS baz ("name", "int")

ฉันต้องการสร้างตารางการค้นหาที่มีแถวสำหรับแต่ละชื่อและลำดับของจำนวนเต็มต่อเนื่องกัน แต่ละแถวดังกล่าวจะประกอบด้วย:

ชื่อ - ค่าของคอลัมน์ชื่อ
เริ่มต้น - จำนวนเต็มแรกในลำดับ
ท้ายที่ต่อเนื่องกัน - ค่าสุดท้ายใน
ช่วงลำดับที่ต่อเนื่องกัน - สิ้นสุด - เริ่ม + 1

แบบสอบถามนี้สร้างผลลัพธ์ตัวอย่างสำหรับตัวอย่างข้างต้น:

--what I need:
SELECT * 
FROM ( VALUES ('foo', 2, 4, 3),
              ('foo', 10, 11, 2),
              ('foo', 13, 13, 1),
              ('bar', 1, 3, 3)
     ) AS contiguous_ranges ("name", "start", "end", span)

เพราะฉันมีหลายแถวประสิทธิภาพจึงดีกว่า ที่กล่าวว่าฉันต้องเรียกใช้แบบสอบถามนี้เพียงครั้งเดียวดังนั้นจึงไม่ใช่ข้อกำหนดที่แน่นอน

ขอบคุณล่วงหน้า!

แก้ไข:

ฉันควรเพิ่มว่ายินดีต้อนรับโซลูชัน PL / pgSQL (โปรดอธิบายเทคนิคแฟนซีใด ๆ - ฉันยังใหม่กับ PL / pgSQL)

วิธีการเกี่ยวกับการใช้ with recursive

มุมมองการทดสอบ:

create view v as 
select *
from ( values ('foo', 2),
              ('foo', 3),
              ('foo', 4),
              ('foo', 10),
              ('foo', 11),
              ('foo', 13),
              ('bar', 1),
              ('bar', 2),
              ('bar', 3)
     ) as baz ("name", "int");

แบบสอบถาม:

with recursive t("name", "int") as ( select "name", "int", 1 as span from v
                                     union all
                                     select "name", v."int", t.span+1 as span
                                     from v join t using ("name")
                                     where v."int"=t."int"+1 )
select "name", "start", "start"+span-1 as "end", span
from( select "name", ("int"-span+1) as "start", max(span) as span
      from ( select "name", "int", max(span) as span 
             from t
             group by "name", "int" ) z
      group by "name", ("int"-span+1) ) z;

ผลลัพธ์:

 name | start | end | span
------+-------+-----+------
 foo  |     2 |   4 |    3
 foo  |    13 |  13 |    1
 bar  |     1 |   3 |    3
 foo  |    10 |  11 |    2
(4 rows)

ฉันสนใจที่จะทราบว่ามันมีประสิทธิภาพอย่างไรในตารางแถวพันล้านของคุณ

คุณสามารถทำได้ด้วยฟังก์ชั่นหน้าต่าง แนวคิดพื้นฐานคือการใช้leadและlagฟังก์ชั่นหน้าต่างเพื่อดึงแถวข้างหน้าและข้างหลังแถวปัจจุบัน จากนั้นเราสามารถคำนวณได้ถ้าเรามีจุดเริ่มต้นหรือจุดสิ้นสุดของลำดับ:

create temp view temp_view as
    select
        n,
        val,
        (lead <> val + 1 or lead is null) as islast,
        (lag <> val - 1 or lag is null) as isfirst,
        (lead <> val + 1 or lead is null) and (lag <> val - 1 or lag is null) as orphan
    from
    (
        select
            n,
            lead(val, 1) over( partition by n order by n, val),
            lag(val, 1) over(partition by n order by n, val ),
            val
        from test
        order by n, val
    ) as t
;  
select * from temp_view;
 n  | val | islast | isfirst | orphan 
-----+-----+--------+---------+--------
 bar |   1 | f      | t       | f
 bar |   2 | f      | f       | f
 bar |   3 | t      | f       | f
 bar |  24 | t      | t       | t
 bar |  42 | t      | t       | t
 foo |   2 | f      | t       | f
 foo |   3 | f      | f       | f
 foo |   4 | t      | f       | f
 foo |  10 | f      | t       | f
 foo |  11 | t      | f       | f
 foo |  13 | t      | t       | t
(11 rows)

(ฉันใช้มุมมองดังนั้นตรรกะจะง่ายต่อการติดตามด้านล่าง) ดังนั้นตอนนี้เรารู้แล้วว่าแถวนั้นเป็นจุดเริ่มต้นหรือจุดสิ้นสุด เราต้องยุบมันลงในแถว:

select
    n as "name",
    first,
    coalesce (last, first) as last,
    coalesce (last - first + 1, 1) as span
from
(
    select
    n,
    val as first,
    -- this will not be excellent perf. since were calling the view
    -- for each row sequence found. Changing view into temp table 
    -- will probably help with lots of values.
    (
        select min(val)
        from temp_view as last
        where islast = true
        -- need this since isfirst=true, islast=true on an orphan sequence
        and last.orphan = false
        and first.val < last.val
        and first.n = last.n
    ) as last
    from
        (select * from temp_view where isfirst = true) as first
) as t
;

 name | first | last | span 
------+-------+------+------
 bar  |     1 |    3 |    3
 bar  |    24 |   24 |    1
 bar  |    42 |   42 |    1
 foo  |     2 |    4 |    3
 foo  |    10 |   11 |    2
 foo  |    13 |   13 |    1
(6 rows)

ดูเหมือนถูกต้องสำหรับฉัน :)

โซลูชันฟังก์ชั่นหน้าต่างอื่น ไม่มีความคิดเกี่ยวกับประสิทธิภาพฉันได้เพิ่มแผนการดำเนินการในตอนท้าย (แม้ว่าจะมีแถวน้อยมาก แต่ก็อาจไม่คุ้มค่ามากนัก) หากคุณต้องการเล่น: ทดสอบ SQL-Fiddle

ตารางและข้อมูล:

CREATE TABLE baz
( name VARCHAR(10) NOT NULL
, i INT  NOT NULL
, UNIQUE  (name, i)
) ;

INSERT INTO baz
  VALUES 
    ('foo', 2),
    ('foo', 3),
    ('foo', 4),
    ('foo', 10),
    ('foo', 11),
    ('foo', 13),
    ('bar', 1),
    ('bar', 2),
    ('bar', 3)
  ;

ค้นหา:

SELECT a.name     AS name
     , a.i        AS start
     , b.i        AS "end"
     , b.i-a.i+1  AS span
FROM
      ( SELECT name, i
             , ROW_NUMBER() OVER (PARTITION BY name ORDER BY i) AS rn
        FROM baz AS a
        WHERE NOT EXISTS
              ( SELECT * 
                FROM baz AS prev
                WHERE prev.name = a.name
                  AND prev.i = a.i - 1
              ) 
      ) AS a
    JOIN
      ( SELECT name, i 
             , ROW_NUMBER() OVER (PARTITION BY name ORDER BY i) AS rn
        FROM baz AS a
        WHERE NOT EXISTS
              ( SELECT * 
                FROM baz AS next
                WHERE next.name = a.name
                  AND next.i = a.i + 1
              )
      ) AS b
    ON  b.name = a.name
    AND b.rn  = a.rn
 ; 

แผนแบบสอบถาม

Merge Join (cost=442.74..558.76 rows=18 width=46)
Merge Cond: ((a.name)::text = (a.name)::text)
Join Filter: ((row_number() OVER (?)) = (row_number() OVER (?)))
-> WindowAgg (cost=221.37..238.33 rows=848 width=42)
-> Sort (cost=221.37..223.49 rows=848 width=42)
Sort Key: a.name, a.i
-> Merge Anti Join (cost=157.21..180.13 rows=848 width=42)
Merge Cond: (((a.name)::text = (prev.name)::text) AND (((a.i - 1)) = prev.i))
-> Sort (cost=78.60..81.43 rows=1130 width=42)
Sort Key: a.name, ((a.i - 1))
-> Seq Scan on baz a (cost=0.00..21.30 rows=1130 width=42)
-> Sort (cost=78.60..81.43 rows=1130 width=42)
Sort Key: prev.name, prev.i
-> Seq Scan on baz prev (cost=0.00..21.30 rows=1130 width=42)
-> Materialize (cost=221.37..248.93 rows=848 width=50)
-> WindowAgg (cost=221.37..238.33 rows=848 width=42)
-> Sort (cost=221.37..223.49 rows=848 width=42)
Sort Key: a.name, a.i
-> Merge Anti Join (cost=157.21..180.13 rows=848 width=42)
Merge Cond: (((a.name)::text = (next.name)::text) AND (((a.i + 1)) = next.i))
-> Sort (cost=78.60..81.43 rows=1130 width=42)
Sort Key: a.name, ((a.i + 1))
-> Seq Scan on baz a (cost=0.00..21.30 rows=1130 width=42)
-> Sort (cost=78.60..81.43 rows=1130 width=42)
Sort Key: next.name, next.i
-> Seq Scan on baz next (cost=0.00..21.30 rows=1130 width=42)

บน SQL Server ฉันจะเพิ่มอีกหนึ่งคอลัมน์ชื่อ previousInt:

SELECT *
FROM ( VALUES ('foo', 2, NULL),
              ('foo', 3, 2),
              ('foo', 4, 3),
              ('foo', 10, 4),
              ('foo', 11, 10),
              ('foo', 13, 11),
              ('bar', 1, NULL),
              ('bar', 2, 1),
              ('bar', 3, 2)
     ) AS baz ("name", "int", "previousInt")

ฉันจะใช้ข้อ จำกัด การตรวจสอบเพื่อให้แน่ใจว่า previousInt <int และข้อ จำกัด FK (ชื่อ, previousInt) อ้างถึง (ชื่อ, int) และข้อ จำกัด เพิ่มเติมอีกสองสามข้อเพื่อรับรองความสมบูรณ์ของข้อมูลที่กันน้ำ การเลือกช่องว่างนั้นเป็นเรื่องเล็กน้อย:

SELECT NAME, PreviousInt, Int from YourTable WHERE PreviousInt < Int - 1;

เพื่อเพิ่มความเร็วฉันอาจสร้างดัชนีที่กรองซึ่งจะรวมเฉพาะช่องว่าง ซึ่งหมายความว่าช่องว่างทั้งหมดของคุณได้รับการคำนวณล่วงหน้าดังนั้นการเลือกจึงรวดเร็วมากและข้อ จำกัด ทำให้มั่นใจได้ว่าความสมบูรณ์ของข้อมูลที่คำนวณไว้ล่วงหน้าของคุณ ฉันใช้โซลูชั่นดังกล่าวมากมายพวกเขาอยู่ในระบบของฉัน

คุณสามารถค้นหาวิธี Tabibitosan:

https://community.oracle.com/docs/DOC-915680
http://rwijk.blogspot.com/2014/01/tabibitosan.html
https://www.xaprb.com/blog/2006/03/22/find-contiguous-ranges-with-sql/

โดยทั่วไป:

SQL> create table mytable (nr)
  2  as
  3  select 1 from dual union all
  4  select 2 from dual union all
  5  select 3 from dual union all
  6  select 6 from dual union all
  7  select 7 from dual union all
  8  select 11 from dual union all
  9  select 18 from dual union all
 10  select 19 from dual union all
 11  select 20 from dual union all
 12  select 21 from dual union all
 13  select 22 from dual union all
 14  select 25 from dual
 15  /

 Table created.

 SQL> with tabibitosan as
 2  ( select nr
 3         , nr - row_number() over (order by nr) grp
 4      from mytable
 5  )
 6  select min(nr)
 7       , max(nr)
 8    from tabibitosan
 9   group by grp
10   order by grp
11  /

   MIN(NR)    MAX(NR)
---------- ----------
         1          3
         6          7
        11         11
        18         22
        25         25

5 rows selected.

ฉันคิดว่าประสิทธิภาพนี้ดีกว่า:

SQL> r
  1  select min(nr) as range_start
  2    ,max(nr) as range_end
  3  from (-- our previous query
  4    select nr
  5      ,rownum
  6      ,nr - rownum grp
  7    from  (select nr
  8       from   mytable
  9       order by 1
 10      )
 11   )
 12  group by grp
 13* order by 1

RANGE_START  RANGE_END
----------- ----------
      1      3
      6      7
     11     11
     18     22
     25     25

แผนคร่าวๆ:

• เลือกขั้นต่ำสำหรับแต่ละชื่อ (จัดกลุ่มตามชื่อ)
• เลือกขั้นต่ำ 2 สำหรับแต่ละชื่อโดยที่ min2> min1 และไม่มีอยู่ (แบบสอบถามย่อย: SEL min2-1)
• Sel max val1> min val1 โดยที่ max val1 <min val2

ทำซ้ำตั้งแต่ 2 จนกว่าจะไม่มีการอัพเดตเกิดขึ้นอีก จากนั้นมันจะซับซ้อนขึ้น Gordian ด้วยการรวมกลุ่มมากกว่านาทีและนาทีสูงสุด ฉันเดาว่าฉันจะไปสำหรับการเขียนโปรแกรมภาษา

PS: ตารางตัวอย่างที่ดีที่มีค่าตัวอย่างน้อย ๆ น่าจะดีซึ่งทุกคนสามารถใช้ได้ดังนั้นทุกคนจะไม่สร้างข้อมูลทดสอบของเขาตั้งแต่ต้น

การแก้ปัญหานี้เป็นแรงบันดาลใจจากเนทค 'คำตอบโดยใช้ฟังก์ชั่นและข้อ windowing มากกว่า น่าสนใจพอคำตอบนั้นกลับไปเป็นคำถามย่อยที่มีการอ้างอิงภายนอก เป็นไปได้ที่จะรวมแถวให้เสร็จสมบูรณ์โดยใช้ฟังก์ชั่นหน้าต่างอีกระดับหนึ่ง มันอาจดูไม่สวยเกินไป แต่ฉันคิดว่ามันมีประสิทธิภาพมากกว่าเพราะใช้ตรรกะในตัวของฟังก์ชั่นหน้าต่างทรงพลัง

ฉันรู้จากโซลูชันของเนทว่าชุดของแถวเริ่มต้นได้จัดทำค่าสถานะที่จำเป็นเป็น 1) เลือกค่าเริ่มต้นและค่าสิ้นสุดของช่วงและ 2) เพื่อกำจัดแถวพิเศษในระหว่างนั้น แบบสอบถามมีแบบสอบถามย่อยที่ซ้อนกันสองส่วนที่ลึกเท่านั้นเนื่องจากข้อ จำกัด ของฟังก์ชันการเรียงหน้าต่างซึ่ง จำกัด วิธีการใช้ชื่อแทนคอลัมน์ ฉันสามารถสร้างผลลัพธ์ได้ด้วยแบบสอบถามย่อยเดียว

หมายเหตุอื่น ๆ : ต่อไปนี้เป็นรหัสสำหรับ SQLite3 ภาษา SQLite นั้นมาจาก postgresql ดังนั้นมันจึงคล้ายกันมากและอาจทำงานไม่เปลี่ยนแปลง ฉันเพิ่มข้อ จำกัด การกำหนดกรอบลงในส่วนคำสั่ง OVER เนื่องจากฟังก์ชันlag()และlead()ต้องการเพียงหน้าต่างแถวเดียวก่อนและหลังตามลำดับ (ดังนั้นจึงไม่จำเป็นต้องเก็บชุดเริ่มต้นของแถวก่อนหน้าทั้งหมดไว้ ) ฉันเลือกใช้ชื่อfirstและlastเนื่องจากคำendสงวนไว้

create temp view test as 
with cte(name, int) AS (
select * from ( values ('foo', 2),
              ('foo', 3),
              ('foo', 4),
              ('foo', 10),
              ('foo', 11),
              ('foo', 13),
              ('bar', 1),
              ('bar', 2),
              ('bar', 3) ))
select * from cte;


SELECT name,
       int AS first, 
       endpoint AS last,
       (endpoint - int + 1) AS span
FROM ( SELECT name, 
             int, 
             CASE WHEN prev <> 1 AND next <> -1 -- orphan
                  THEN int
                WHEN next = -1 -- start of range
                  THEN lead(int) OVER (PARTITION BY name 
                                       ORDER BY int 
                                       ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)
                ELSE null END
             AS endpoint
        FROM ( SELECT name, 
                   int,
                   coalesce(int - lag(int) OVER (PARTITION BY name 
                                                 ORDER BY int 
                                                 ROWS BETWEEN 1 PRECEDING AND CURRENT ROW), 
                            0) AS prev,
                   coalesce(int - lead(int) OVER (PARTITION BY name 
                                                  ORDER BY int 
                                                  ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING),
                            0) AS next
              FROM test
            ) AS mark_boundaries
        WHERE NOT (prev = 1 AND next = -1) -- discard values within range
      ) as raw_ranges
WHERE endpoint IS NOT null
ORDER BY name, first

ผลลัพธ์เป็นเหมือนคำตอบอื่น ๆ ตามที่คาดไว้:

 name | first | last | span
------+-------+------+------
 bar  |     1 |    3 |   3
 foo  |     2 |    4 |   3
 foo  |    10 |   11 |   2
 foo  |    13 |   13 |   1