win-loss-tie 데이터에서 연속 카운트 및 연속 유형 가져 오기

내가 만든 SQL 바이올린을 그 누구보다 쉽게 일을 만드는 경우이 질문에 대해.

나는 일종의 판타지 스포츠 데이터베이스를 가지고 있고 내가 알아 내려고하는 것은 "현재 행진"데이터를 만드는 방법입니다 (팀이 마지막 2 경기에서 승리 한 경우 'W2'또는 잃어버린 경우 'L1') 이전 경기에서 승리 한 후 마지막 경기-또는 최근 경기에 묶인 경우 'T1')

기본 스키마는 다음과 같습니다.

CREATE TABLE FantasyTeams (
  team_id BIGINT NOT NULL
)

CREATE TABLE FantasyMatches(
    match_id BIGINT NOT NULL,
    home_fantasy_team_id BIGINT NOT NULL,
    away_fantasy_team_id BIGINT NOT NULL,
    fantasy_season_id BIGINT NOT NULL,
    fantasy_league_id BIGINT NOT NULL,
    fantasy_week_id BIGINT NOT NULL,
    winning_team_id BIGINT NULL
)

값 NULL의 winning_team_id열은 일치 넥타이를 나타낸다.

다음은 6 개 팀과 3 주 분량의 매치업에 대한 샘플 데이터가 포함 된 샘플 DML 문입니다.

INSERT INTO FantasyTeams
SELECT 1
UNION
SELECT 2
UNION
SELECT 3
UNION
SELECT 4
UNION
SELECT 5
UNION
SELECT 6

INSERT INTO FantasyMatches
SELECT 1, 2, 1, 2, 4, 44, 2
UNION
SELECT 2, 5, 4, 2, 4, 44, 5
UNION
SELECT 3, 6, 3, 2, 4, 44, 3
UNION
SELECT 4, 2, 4, 2, 4, 45, 2
UNION
SELECT 5, 3, 1, 2, 4, 45, 3
UNION
SELECT 6, 6, 5, 2, 4, 45, 6
UNION
SELECT 7, 2, 6, 2, 4, 46, 2
UNION
SELECT 8, 3, 5, 2, 4, 46, 3
UNION
SELECT 9, 4, 1, 2, 4, 46, NULL

GO

다음은 원하는 출력의 예입니다 (위의 DML을 기반으로 함). 유도 방법을 알아 내기조차 시작하지 못했습니다.

| TEAM_ID | STEAK_TYPE | STREAK_COUNT |
|---------|------------|--------------|
|       1 |          T |            1 |
|       2 |          W |            3 |
|       3 |          W |            3 |
|       4 |          T |            1 |
|       5 |          L |            2 |
|       6 |          L |            1 |

하위 쿼리와 CTE를 사용하여 다양한 방법을 시도했지만 함께 사용할 수 없습니다. 나중에 이것을 실행하기 위해 큰 데이터 세트를 가질 수 있으므로 커서 사용을 피하고 싶습니다. 어떻게 든이 데이터를 조인하는 테이블 변수와 관련된 방법이있을 수 있지만 여전히 작업 중입니다.

추가 정보 : 다양한 수의 팀이있을 수 있으며 (6과 10 사이의 짝수) 매 경기마다 총 경기가 1 씩 증가합니다. 내가 어떻게 해야하는지에 대한 아이디어가 있습니까?

SQL Server 2012를 사용하므로 몇 가지 새로운 윈도우 기능을 사용할 수 있습니다.

with C1 as
(
  select T.team_id,
         case
           when M.winning_team_id is null then 'T'
           when M.winning_team_id = T.team_id then 'W'
           else 'L'
         end as streak_type,
         M.match_id
  from FantasyMatches as M
    cross apply (values(M.home_fantasy_team_id),
                       (M.away_fantasy_team_id)) as T(team_id)
), C2 as
(
  select C1.team_id,
         C1.streak_type,
         C1.match_id,
         lag(C1.streak_type, 1, C1.streak_type) 
           over(partition by C1.team_id 
                order by C1.match_id desc) as lag_streak_type
  from C1
), C3 as
(
  select C2.team_id,
         C2.streak_type,
         sum(case when C2.lag_streak_type = C2.streak_type then 0 else 1 end) 
           over(partition by C2.team_id 
                order by C2.match_id desc rows unbounded preceding) as streak_sum
  from C2
)
select C3.team_id,
       C3.streak_type,
       count(*) as streak_count
from C3
where C3.streak_sum = 0
group by C3.team_id,
         C3.streak_type
order by C3.team_id;

SQL 바이올린

C1streak_type각 팀과 경기를 계산합니다 .

C2로 이전 streak_type주문을 찾습니다 match_id desc.

C3가 마지막 값과 같으면 long streak_sum을 match_id desc유지하여 순서대로 누계를 생성 합니다.0streak_type

줄무늬까지 메인 쿼리의 합계 streak_sum입니다 0.

이 문제를 해결하기위한 직관적 인 접근 방식은 다음과 같습니다.

1. 각 팀의 최신 결과 찾기
2. 결과 유형이 일치하면 이전 일치 항목을 확인하고 연속 수에 하나를 추가하십시오.
3. 2 단계를 반복하되 첫 번째 결과가 나오면 즉시 중지

이 전략은 재귀 전략이 효율적으로 구현된다고 가정 할 때 테이블이 커질수록 창 함수 솔루션 (데이터의 전체 스캔을 수행)을 능가 할 수 있습니다. 성공의 열쇠는 효율적으로 색인을 제공하여 행을 빠르게 찾고 (시도를 사용하여) 정렬을 피하는 것입니다. 필요한 색인은 다음과 같습니다.

-- New index #1
CREATE UNIQUE INDEX uq1 ON dbo.FantasyMatches 
    (home_fantasy_team_id, match_id) 
INCLUDE (winning_team_id);

-- New index #2
CREATE UNIQUE INDEX uq2 ON dbo.FantasyMatches 
    (away_fantasy_team_id, match_id) 
INCLUDE (winning_team_id);

쿼리 최적화를 돕기 위해 임시 테이블을 사용하여 현재 행진의 일부를 형성하는 것으로 식별 된 행을 보유합니다. 줄무늬가 일반적으로 짧으면 (따라서 내가 따르는 팀의 경우와 마찬가지로)이 표는 매우 작아야합니다.

-- Table to hold just the rows that form streaks
CREATE TABLE #StreakData
(
    team_id bigint NOT NULL,
    match_id bigint NOT NULL,
    streak_type char(1) NOT NULL,
    streak_length integer NOT NULL,
);

-- Temporary table unique clustered index
CREATE UNIQUE CLUSTERED INDEX cuq ON #StreakData (team_id, match_id);

내 재귀 쿼리 솔루션은 다음과 같습니다 ( SQL Fiddle here ).

-- Solution query
WITH Streaks AS
(
    -- Anchor: most recent match for each team
    SELECT 
        FT.team_id, 
        CA.match_id, 
        CA.streak_type, 
        streak_length = 1
    FROM dbo.FantasyTeams AS FT
    CROSS APPLY
    (
        -- Most recent match
        SELECT
            T.match_id,
            T.streak_type
        FROM 
        (
            SELECT 
                FM.match_id, 
                streak_type =
                    CASE 
                        WHEN FM.winning_team_id = FM.home_fantasy_team_id
                            THEN CONVERT(char(1), 'W')
                        WHEN FM.winning_team_id IS NULL
                            THEN CONVERT(char(1), 'T')
                        ELSE CONVERT(char(1), 'L')
                    END
            FROM dbo.FantasyMatches AS FM
            WHERE 
                FT.team_id = FM.home_fantasy_team_id
            UNION ALL
            SELECT 
                FM.match_id, 
                streak_type =
                    CASE 
                        WHEN FM.winning_team_id = FM.away_fantasy_team_id
                            THEN CONVERT(char(1), 'W')
                        WHEN FM.winning_team_id IS NULL
                            THEN CONVERT(char(1), 'T')
                        ELSE CONVERT(char(1), 'L')
                    END
            FROM dbo.FantasyMatches AS FM
            WHERE
                FT.team_id = FM.away_fantasy_team_id
        ) AS T
        ORDER BY 
            T.match_id DESC
            OFFSET 0 ROWS 
            FETCH FIRST 1 ROW ONLY
    ) AS CA
    UNION ALL
    -- Recursive part: prior match with the same streak type
    SELECT 
        Streaks.team_id, 
        LastMatch.match_id, 
        Streaks.streak_type, 
        Streaks.streak_length + 1
    FROM Streaks
    CROSS APPLY
    (
        -- Most recent prior match
        SELECT 
            Numbered.match_id, 
            Numbered.winning_team_id, 
            Numbered.team_id
        FROM
        (
            -- Assign a row number
            SELECT
                PreviousMatches.match_id,
                PreviousMatches.winning_team_id,
                PreviousMatches.team_id, 
                rn = ROW_NUMBER() OVER (
                    ORDER BY PreviousMatches.match_id DESC)
            FROM
            (
                -- Prior match as home or away team
                SELECT 
                    FM.match_id, 
                    FM.winning_team_id, 
                    team_id = FM.home_fantasy_team_id
                FROM dbo.FantasyMatches AS FM
                WHERE 
                    FM.home_fantasy_team_id = Streaks.team_id
                    AND FM.match_id < Streaks.match_id
                UNION ALL
                SELECT 
                    FM.match_id, 
                    FM.winning_team_id, 
                    team_id = FM.away_fantasy_team_id
                FROM dbo.FantasyMatches AS FM
                WHERE 
                    FM.away_fantasy_team_id = Streaks.team_id
                    AND FM.match_id < Streaks.match_id
            ) AS PreviousMatches
        ) AS Numbered
        -- Most recent
        WHERE 
            Numbered.rn = 1
    ) AS LastMatch
    -- Check the streak type matches
    WHERE EXISTS
    (
        SELECT 
            Streaks.streak_type
        INTERSECT
        SELECT 
            CASE 
                WHEN LastMatch.winning_team_id IS NULL THEN 'T' 
                WHEN LastMatch.winning_team_id = LastMatch.team_id THEN 'W' 
                ELSE 'L' 
            END
    )
)
INSERT #StreakData
    (team_id, match_id, streak_type, streak_length)
SELECT
    team_id,
    match_id,
    streak_type,
    streak_length
FROM Streaks
OPTION (MAXRECURSION 0);

T-SQL 텍스트는 상당히 길지만 쿼리의 각 섹션은이 답변의 시작 부분에 제공된 광범위한 프로세스 개요와 밀접한 관련이 있습니다. 정렬을 피하고 TOP쿼리의 재귀 부분 을 생성하기 위해 특정 트릭을 사용해야하므로 쿼리가 더 오래 걸립니다 (일반적으로 허용되지 않음).

실행 계획은 쿼리와 비교하여 비교적 작고 간단합니다. 아래의 스크린 샷에서 앵커 영역을 노란색으로 표시하고 재귀 부분을 녹색으로 표시했습니다.

임시 테이블에서 행 행을 캡처하면 필요한 요약 결과를 쉽게 얻을 수 있습니다. (임시 테이블을 사용하면 아래 쿼리가 기본 재귀 쿼리와 결합 된 경우 발생할 수있는 정렬 유출이 방지됩니다)

-- Basic results
SELECT
    SD.team_id,
    StreakType = MAX(SD.streak_type),
    StreakLength = MAX(SD.streak_length)
FROM #StreakData AS SD
GROUP BY 
    SD.team_id
ORDER BY
    SD.team_id;

동일한 쿼리를 FantasyTeams테이블 업데이트의 기초로 사용할 수 있습니다 .

-- Update team summary
WITH StreakData AS
(
    SELECT
        SD.team_id,
        StreakType = MAX(SD.streak_type),
        StreakLength = MAX(SD.streak_length)
    FROM #StreakData AS SD
    GROUP BY 
        SD.team_id
)
UPDATE FT
SET streak_type = SD.StreakType,
    streak_count = SD.StreakLength
FROM StreakData AS SD
JOIN dbo.FantasyTeams AS FT
    ON FT.team_id = SD.team_id;

또는 원하는 경우 MERGE:

MERGE dbo.FantasyTeams AS FT
USING
(
    SELECT
        SD.team_id,
        StreakType = MAX(SD.streak_type),
        StreakLength = MAX(SD.streak_length)
    FROM #StreakData AS SD
    GROUP BY 
        SD.team_id
) AS StreakData
    ON StreakData.team_id = FT.team_id
WHEN MATCHED THEN UPDATE SET
    FT.streak_type = StreakData.StreakType,
    FT.streak_count = StreakData.StreakLength;

두 가지 접근 방식 중 하나는 효율적인 실행 계획을 생성합니다 (임시 테이블의 알려진 행 수 기준).

마지막으로 재귀 적 인 방법 match_id은 처리에 자연스럽게 포함하기 때문에 match_id각 행진을 형성 하는 의 목록을 출력에 쉽게 추가 할 수 있습니다 .

SELECT
    S.team_id,
    streak_type = MAX(S.streak_type),
    match_id_list =
        STUFF(
        (
            SELECT ',' + CONVERT(varchar(11), S2.match_id)
            FROM #StreakData AS S2
            WHERE S2.team_id = S.team_id
            ORDER BY S2.match_id DESC
            FOR XML PATH ('')
        ), 1, 1, ''),
    streak_length = MAX(S.streak_length)
FROM #StreakData AS S
GROUP BY 
    S.team_id
ORDER BY
    S.team_id;

산출:

실행 계획 :

결과를 얻는 또 다른 방법은 재귀 CTE에 의한 것입니다.

WITH TeamRes As (
SELECT FT.Team_ID
     , FM.match_id
     , Previous_Match = LAG(match_id, 1, 0) 
                        OVER (PARTITION BY FT.Team_ID ORDER BY FM.match_id)
     , Matches = Row_Number() 
                 OVER (PARTITION BY FT.Team_ID ORDER BY FM.match_id Desc)
     , Result = Case Coalesce(winning_team_id, -1)
                     When -1 Then 'T'
                     When FT.Team_ID Then 'W'
                     Else 'L'
                End 
FROM   FantasyMatches FM
       INNER JOIN FantasyTeams FT ON FT.Team_ID IN 
         (FM.home_fantasy_team_id, FM.away_fantasy_team_id)
), Streaks AS (
SELECT Team_ID, Result, 1 As Streak, Previous_Match
FROM   TeamRes
WHERE  Matches = 1
UNION ALL
SELECT tr.Team_ID, tr.Result, Streak + 1, tr.Previous_Match
FROM   TeamRes tr
       INNER JOIN Streaks s ON tr.Team_ID = s.Team_ID 
                           AND tr.Match_id = s.Previous_Match 
                           AND tr.Result = s.Result
)
Select Team_ID, Result, Max(Streak) Streak
From   Streaks
Group By Team_ID, Result
Order By Team_ID

SQLFiddle 데모