查找具有重叠范围的行

Question

Suppose I have data that looks like this:

    create table tab(id smallint, nums int4range)
    insert into tab values (1, int4range(1,10)), (2, int4range(1,20)), (3,int4range(3,8)), (4,int4range(15,25)), (5,int4range(3,8))

So then select * from tab gives:

 id |  nums
----+---------
  1 | [1,10)
  2 | [1,20)
  3 | [3,8)
  4 | [15,25)
  5 | [3,8)

I want a query that would find the ranges formed from the intersection of these ranges and the id's that fall into those sub-ranges. So the output would look like this in some form:

  nums  | ids
--------+------------
[1,3)   | 1, 2
[3,8)   | 1, 2, 3, 5
[8,10)  | 1, 2
[10,15) | 2
[15,20) | 2, 4
[20,25) | 4

I'm agnostic about the output of the 'ids' column -- an array is what seems logical, but I'm perfectly content with columns for the first, second, third ... nth id in a given range.

I know that there won't be more than five IDs with overlapping ranges, so a fixed number of columns with nulls as needed is perfectly fine. I also know that there won't be ranges with no IDs, if that matters.

Thanks for any help you can provide.

Answer 1

Overlapping ranges

If you want overlapping ranges:

WITH all_intersections
AS
(
SELECT
    t1.id AS id1, 
    t2.id AS id2, 
    t1.nums * /* intersection */ t2.nums AS nums 
FROM
    tab t1 CROSS JOIN tab t2
WHERE
    t1.id <= t2.id  /* Need only 1/2 + diagonal */
),
unique_nums AS
(
SELECT DISTINCT
    nums
FROM
    all_intersections
WHERE 
    nums <> 'empty' 
)
SELECT 
    nums, 
    array(SELECT DISTINCT id1 AS id 
            FROM all_intersections a1 
           WHERE a1.nums = a0.nums
          UNION
          SELECT DISTINCT id2 AS id 
            FROM all_intersections a2 
           WHERE a2.nums = a0.nums
          ORDER BY id
         ) AS ids
FROM
    unique_nums a0 
ORDER BY
    nums ;

That gives the result:

|    nums |     ids |
|---------|---------|
|  [1,10) |     1,2 |
|  [1,20) |       2 |
|   [3,8) | 1,2,3,5 |
| [15,20) |     2,4 |
| [15,25) |       4 |

You can check it at http://sqlfiddle.com/#!15/f83d5/5/0

Non-overlapping ranges

If you want to get non-overlapping ranges (like in your example), this can be done with the following CTE:

WITH bounds AS         /* all bounds */
(
SELECT DISTINCT
    lower(nums) AS b
FROM
    tab
UNION
SELECT DISTINCT
    upper(nums) AS b
FROM 
    tab
),
range_bounds AS        /* pairs of consecutive bounds */
(
SELECT
    b, lead(b) OVER (ORDER BY b) AS next_b 
FROM
    bounds
),
ranges AS              /* convert the pairs to ranges */
(
SELECT
    int4range(b, next_b) AS nums
FROM
    range_bounds 
WHERE
    next_b is not null  -- ignore last
)
SELECT                 /* take every range and find intersection with originals */
    nums, 
    ARRAY
      (SELECT id 
        FROM tab
       WHERE tab.nums && ranges.nums
      ) AS ids
FROM 
    ranges ;

The result of execution is:

|    nums |     ids |
|---------|---------|
|   [1,3) |     1,2 |
|   [3,8) | 1,2,3,5 |
|  [8,10) |     1,2 |
| [10,15) |       2 |
| [15,20) |     2,4 |
| [20,25) |       4 |

Which is the result of your example.

This assumes:

• All your ranges are constructed with including lower bound [ and excluding upper bound ) . [It won't produce the right results in other cases.]

The idea is:

1. You take all bounds of the ranges (no matter whether lower or upper)
2. Sort them
3. Make ranges from any two consecutive bounds
4. See which original ranges they overlap with to construct the ids

Check it at http://sqlfiddle.com/#!15/f83d5/10/0

NOTE: This can be further compressed if you want to avoid the CTEs, by pure substitution:

SELECT 
    nums, ARRAY
          (SELECT id 
             FROM tab
            WHERE tab.nums && ranges.nums
           ) AS ids
FROM 
    (SELECT
        int4range(b, next_b) AS nums
    FROM
        (SELECT
            b, lead(b) OVER (ORDER BY b) AS next_b 
        FROM
            (SELECT DISTINCT lower(nums) AS b FROM tab
             UNION
             SELECT DISTINCT upper(nums) AS b FROM tab
            ) AS bounds
        ) AS range_bounds 
    WHERE
        next_b is not null
    ) AS ranges 
ORDER BY
  nums ;

Check it at http://sqlfiddle.com/#!15/f83d5/15/0

Answer 2

SELECT uniquenums.nums, array_agg(id) ids
FROM (
        SELECT numsgroup, int4range(min(boundary), max(boundary)) nums
        FROM (
                SELECT boundary, row_number() OVER (ORDER BY boundary, seriesvalue) / 2 AS numsgroup
                FROM (
                        SELECT DISTINCT upper(nums) AS boundary FROM tab
                        UNION
                        SELECT DISTINCT lower(nums) AS boundary FROM tab
                ) AS A
                JOIN (
                        SELECT generate_series(1, 2) AS seriesvalue
                ) AS B ON true
        ) AS A
        GROUP BY numsgroup
        HAVING COUNT(*) > 1
) AS uniquenums
JOIN tab ON tab.nums && uniquenums.nums
GROUP BY uniquenums.nums
ORDER BY uniquenums.nums

How does it work?

1. Extract all distinct boundaries regardless of lower or upper
2. Duplicate each boundary by joining a helper table expression with two rows
3. Assing each resulting row a group number such that two consecutive boundaries are assigned the same group number
4. Group by these numbers and build new ranges using the consecutive boundaries
5. Find ranges in tab that are overlapping the ranges just calculated
6. Aggregate the IDs of the found ranges in an array

Answer 3

select rng as nums, array_agg(id) as ids
from (  
    select int4range(n, lead(n) over (order by n)) as rng
    from (  
        select distinct lower(nums) n
        from tab
        union
        select distinct upper(nums) n
        from tab
        ) s
    ) s
join tab on rng && nums
group by 1
order by 1;

  nums   |    ids    
---------+-----------
 [1,3)   | {1,2}
 [3,8)   | {1,2,3,5}
 [8,10)  | {1,2}
 [10,15) | {2}
 [15,20) | {2,4}
 [20,25) | {4}
(6 rows)