Oracle SQL 或 PLSQL。按分区选择行，其值具有特定顺序

Question

任务：选择至少连续参加2场比赛的运动员（2场比赛接连进行；1-2-3-4-5：2&4或1&3&5不行，1&2可以，1&2&3可以， 1&2 和 4&5 都可以）。 问题：找到最好的方法（更快，更少的资源）

工作台：

每个比赛 ID 都有一个 hold_date。

每个sportsman_id 每个competition_id 只有一个结果。

这适用于结果表中的 25 行：

SELECT DISTINCT sportsman_id, sportsman_name, rank, year_of_birth, personal_record, country
FROM
    (
    SELECT sportsman_id, hold_date,
        LAG (comp_order, 1) OVER (PARTITION BY sportsman_id ORDER BY sportsman_id) prev_comp_number
        , comp_order
    FROM result
    INNER JOIN
        (
        SELECT hold_date, ROW_NUMBER() OVER (ORDER BY hold_date) AS comp_order
        FROM
            (
            SELECT DISTINCT hold_date
            FROM result
            )
        ) USING (hold_date)
    ORDER BY sportsman_id, comp_order
    )
INNER JOIN sportsman USING (sportsman_id)
WHERE comp_order-prev_comp_number=1
;

使用 cmets 的代码截图：

样本数据：

上面代码的结果（=期望的结果）

假设有数百万行（数以千计的比赛和数以千计的运动员）。我的代码有多可靠？

如果sportsman_id 只出现一次，我认为通过排除行来减少行数（如果运动员只参加了一场比赛（获得结果），他显然不能成为那个人）。 像这样的东西：（还没有实现（不知道如何或最有可能何时/何地））

SELECT re.hold_date, r.sportsman_id
FROM result r
INNER JOIN result re ON (re.sportsman_id=r.sportsman_id)
GROUP BY r.sportsman_id, re.hold_date
HAVING COUNT(r.sportsman_id) > 1
;

那么，我猜我用 LAG 只会将现有列加倍，这还不错？

使用 PLSQL 有更简单的方法吗？或者有一个函数可以完成我的代码的某些部分？

Answer 1

如果您对包含完整比赛列表的结果执行分区外连接，那么当竞争对手没有参加比赛时，您将拥有NULL 行。然后你可以用MATCH_RECOGNIZE依次比较行，COUNT他们参加的顺序比赛的数量，排除只参加了一场比赛但没有参加前后比赛的运动员。

SELECT sportsman_id
FROM   (
  SELECT sportsman_id,
         c.competition_id,
         c.hold_date,
         NVL2( r.competition_id, 1, 0 ) AS attended
  FROM   ( SELECT DISTINCT
                  competition_id,
                  hold_date
           FROM   result
         ) c
         LEFT OUTER JOIN result r
         PARTITION BY ( r.sportsman_id )
         ON ( c.competition_id = r.competition_id )
)
MATCH_RECOGNIZE (
  PARTITION BY sportsman_id
  ORDER BY hold_date
  MEASURES COUNT(*) AS num_sequential
  ONE ROW PER MATCH
  PATTERN ( ATTENDED_COMP+ )
  DEFINE
    ATTENDED_COMP AS (
      ATTENDED_COMP.attended = 1
    )
)
GROUP BY sportsman_id
HAVING MIN( num_sequential ) > 1;

所以，对于样本数据：

CREATE TABLE result ( competition_id, sportsman_id, hold_date ) AS
SELECT 1, 1, DATE '2020-01-01' FROM DUAL UNION ALL
SELECT 2, 1, DATE '2020-02-01' FROM DUAL UNION ALL
SELECT 3, 1, DATE '2020-03-01' FROM DUAL UNION ALL
SELECT 4, 1, DATE '2020-04-01' FROM DUAL UNION ALL
SELECT 5, 1, DATE '2020-05-01' FROM DUAL UNION ALL
SELECT 1, 2, DATE '2020-01-01' FROM DUAL UNION ALL
SELECT 2, 2, DATE '2020-02-01' FROM DUAL UNION ALL
SELECT 4, 2, DATE '2020-04-01' FROM DUAL UNION ALL
SELECT 5, 2, DATE '2020-05-01' FROM DUAL UNION ALL
SELECT 2, 3, DATE '2020-02-01' FROM DUAL UNION ALL
SELECT 4, 3, DATE '2020-04-01' FROM DUAL UNION ALL
SELECT 1, 4, DATE '2020-01-01' FROM DUAL UNION ALL
SELECT 3, 4, DATE '2020-03-01' FROM DUAL UNION ALL
SELECT 5, 4, DATE '2020-05-01' FROM DUAL UNION ALL
SELECT 1, 5, DATE '2020-01-01' FROM DUAL UNION ALL
SELECT 2, 5, DATE '2020-02-01' FROM DUAL UNION ALL
SELECT 5, 5, DATE '2020-05-01' FROM DUAL;

输出是：

| SPORTSMAN_ID | | ------------: | | 1 | | 2 |

db小提琴here

---

如果您想要参加过任何一组连续比赛的运动员（无论他们的所有比赛是否都包含在连续组中），那么您可以将最后一行更改为：

HAVING MAX( num_sequential ) > 1;

输出将是：

| SPORTSMAN_ID | | ------------: | | 1 | | 2 | | 5 |

db小提琴here

---

或者，如果您想了解匹配范围的详细信息，您可以使用PATTERN ( ATTENDED_COMP{2,} ) 仅匹配竞争对手连续参加两次或更多比赛的连续组：

SELECT *
FROM   (
  SELECT sportsman_id,
         c.competition_id,
         c.hold_date,
         NVL2( r.competition_id, 1, 0 ) AS attended
  FROM   ( SELECT DISTINCT
                  competition_id,
                  hold_date
           FROM   result
         ) c
         LEFT OUTER JOIN result r
         PARTITION BY ( r.sportsman_id )
         ON ( c.competition_id = r.competition_id )
)
MATCH_RECOGNIZE (
  PARTITION BY sportsman_id
  ORDER BY hold_date
  MEASURES
    FIRST( competition_id ) AS first_competition_id,
    FIRST( hold_date ) AS first_hold_date,
    LAST( competition_id ) AS last_competition_id,
    LAST( hold_date ) AS last_hold_date
  ONE ROW PER MATCH
  PATTERN ( ATTENDED_COMP{2,} )
  DEFINE
    ATTENDED_COMP AS ( ATTENDED_COMP.attended = 1 )
)

输出：

SPORTSMAN_ID | FIRST_COMPETITION_ID | FIRST_HOLD_DATE | LAST_COMPETITION_ID | LAST_HOLD_DATE ------------: | -------------------: | :----------------- | ------------------: | :----------------- 1 | 1 | 2020-01-01 00:00:00 | 5 | 2020-05-01 00:00:00 2 | 1 | 2020-01-01 00:00:00 | 2 | 2020-02-01 00:00:00 2 | 4 | 2020-04-01 00:00:00 | 5 | 2020-05-01 00:00:00 5 | 1 | 2020-01-01 00:00:00 | 2 | 2020-02-01 00:00:00

db小提琴here

Answer 2

您可以通过使用 Tabibitosan 方法仅读取一次表格来将连续比赛组合在一起https://www.red-gate.com/simple-talk/sql/t-sql-programming/the-sql-of-gaps-and-islands-in-sequences/#:%7E:text=The%20SQL%20of%20Gaps%20and%20Islands%20in%20Sequences,...%204%20Performance%20Comparison%20of%20Gaps%20Solutions.%20

在这里您必须使用 add_months，因为您的比赛相隔数月：

select sportsman_id, min(hold_date) , max(hold_date), comps_in_island
from (
 select  competition_id, sportsman_id, hold_date, island, count(*) over (partition by sportsman_id,island) comps_in_island
 from (
  select  competition_id, sportsman_id, hold_date , add_months(hold_date,-1*row_number() over(partition by sportsman_id order by hold_date)) island
  from    result
 )
)
where comps_in_island > 1
group by sportsman_id, island, comps_in_island;

数据库小提琴：https://dbfiddle.uk/?rdbms=oracle_18&fiddle=1b707262722bc555ad851aee029b347a

-编辑 我对一些数据感到困惑，看起来重要的不是日期而是比赛ID。如果您有一个无间隙的competition_id 序列，这会变得更简单（所以比赛65786162213 在4 之后是657 亿个事件）

select sportsman_id, min(competition_id) , max(competition_id), comps_in_island
from (
 select  competition_id, sportsman_id, hold_date, island, count(*) over (partition by sportsman_id,island) comps_in_island
 from 
  select  competition_id, sportsman_id, hold_date , competition_id -row_number() over(partition by sportsman_id order by competition_id)) island
  from    result
 )
)
where comps_in_island > 1
group by sportsman_id, island, comps_in_island;

或者，如果您需要先计算出比赛数量，您只需要一个额外的子查询，使用dense_rank 来对唯一的competition_ids 进行排名：

select sportsman_id, min(competition_id) , max(competition_id), comps_in_island
from (
 select  competition_id, sportsman_id, hold_date, island, count(*) over (partition by sportsman_id,island) comps_in_island
 from (
  select  competition_id, sportsman_id, hold_date , comp_number -row_number() over(partition by sportsman_id order by comp_number) island
  from (  
   select  competition_id, sportsman_id, hold_date , dense_rank() over (partition by null order by competition_id) comp_number
   from    result
  )
 )
)
where comps_in_island > 1
group by sportsman_id, island, comps_in_island;

这确实假设您关心的每个可能的competition_id 在结果中都有一行。

Answer 3

如果你只想要一个至少连续参加过两次比赛的运动员名单，那么使用lag() juste 一次就足够了：

select distinct sportman_id
from (
    select sportman_id, competition_id
        lag(competition_id) over(partition by sportman_id, oder by competition_id) lag_competition_id
    from result r
) r
where competition_id = lag_competition_id + 1

exists可以带上对应的sportsman行：

select s.*
from sportman s
where exists (
    select 1
    from (
        select sportman_id, competition_id
            lag(competition_id) over(partition by sportman_id, oder by competition_id) lag_competition_id
        from result r
    ) r
    where r.competition_id = r.lag_competition_id + 1 and r.sportman_id = s.sportman_id
)

Answer 4

你说每次比赛总是只有一个日期。因此，该日期应位于比赛表中，而不是结果表中。您还说日期不重叠（同一日期没有两场比赛 - 这也可以通过限制来确保，是比赛表中的日期）。

在第一步中，按顺序获取比赛/日期。使用您的数据模型：

select distinct hold_date
from result
order by hold_date;

要快速获得此结果，请提供日期索引：

create index idx1 on result (hold_date);

您甚至可以使用ROW_NUMBER 对它们进行编号，或者使用LAG 或LEAD 来查看日期及其相邻日期。

现在，寻找连续参加两项赛事的运动员的最佳方法在很大程度上取决于运动员一般参加的频率。

1. 如果他们很少参与，比如通常只有两次，我们可以加入并快速查看结果。
2. 如果他们经常参与，例如，通常参与大约一半的事件，我们希望遍历事件并在找到连续事件后停止，而不是继续阅读。

这是对第二种方法的查询。我们使用递归查询（因为这是我们在 SQL 中应用迭代过程的方式）。我们从所有运动员和第一次约会开始。然后我们去第二次约会，为所有参加过的人停下来。剩下的我们看第三次约会，然后再为参加第二次和第三次的人停下来。以此类推。

应该有一个关于日期和运动员的索引，以便快速查找结果行。我什至会提供两个索引，因为我不知道哪一列更具选择性。所以，让 DBMS 来决定吧。

create index idx2 on result (hold_date, sportsman_id);
create index idx3 on result (sportsman_id, hold_date);

这里是查询：

with dates as 
(
  select
    hold_date,
    lead(hold_date) over (order by hold_date) as next_date,
    min(hold_date) over (order by hold_date) as min_date
  from (select distinct hold_date from result)
)
, cte (sportsman_id, sportsman_name, rank, year_of_birth, personal_record, country,
       hold_date, next_date, was_in, is_in) as
(
  select
    s.sportsman_id, s.sportsman_name, s.rank, s.year_of_birth,
    s.personal_record, s.country, d.hold_date, d.next_date, 'NO',
    case when r.hold_date is not null then 'YES' else 'NO' end
  from sportsman s
  cross join (select * from dates where hold_date = min_date) d
  left join result r on r.sportsman_id = s.sportsman_id
                     and r.hold_date = d.hold_date
  union all
  select
    s.sportsman_id, s.sportsman_name, s.rank, s.year_of_birth,
    s.personal_record, s.country, d.hold_date, d.next_date, s.is_in,
    case when r.hold_date is not null then 'YES' else 'NO' end
  from cte s
  join dates d on d.hold_date = s.next_date
  left join result r on r.sportsman_id = s.sportsman_id
                     and r.hold_date = d.hold_date
  where not (s.was_in = 'YES' and s.is_in = 'YES')
)
select sportsman_id, sportsman_name, rank, year_of_birth, personal_record, country
from cte
where was_in = 'YES' and is_in = 'YES';