최신 이력 조회: Top-1·ROW_NUMBER·DENSE_RANK·KEEP

A. 특정 Key의 최신 행 한 건
B. 모든 Key별 최신 행 한 건
C. 최신 시각과 동률인 모든 행
D. 최신 행의 일부 Column 값만 Group별로 추출
E. 특정 기준 시점 이하의 최신 행

정확히 한 행
→ Top-1·ROW_NUMBER
→ 유일한 전체 ORDER BY 필요

최신 시각의 동률 전체
→ DENSE_RANK
→ 동률을 일부러 유지

Group별 최신 Rank의 일부 값
→ KEEP(DENSE_RANK FIRST·LAST)
→ Rank 집합 안에서 Aggregate 수행

DEVICE_ID | CHANGE_TIME        | CHANGE_SEQ | STATUS | HISTORY_ID
----------+--------------------+------------+--------+-----------
A         | 2026-07-01 09:00   | 1          | READY  | 101
A         | 2026-07-10 10:00   | 1          | RUN    | 102
A         | 2026-07-10 10:00   | 2          | STOP   | 103
B         | 2026-07-03 08:00   | 1          | READY  | 201

최신 시각
→ 시간 Key의 최대값

최신 행
→ 시간 + 순번 + PK의 전체 순서에서 첫 행

최신 상태값
→ 최신 행의 STATUS

최신 시각 동률 전체
→ 시간 Key가 최대인 모든 행

ORDER BY CHANGE_TIME DESC,
         CHANGE_SEQ DESC,
         HISTORY_ID DESC

SELECT h.device_id,
       h.change_time,
       h.change_seq,
       h.status,
       h.history_id
FROM   device_status_history h
WHERE  h.device_id = :device_id
ORDER  BY h.change_time DESC NULLS LAST,
          h.change_seq DESC,
          h.history_id DESC
FETCH FIRST 1 ROW ONLY;

DEVICE_ID 등치 탐색
→ 최신 방향으로 Index 범위 탐색
→ 첫 행에서 중단
→ 필요한 Table Column 반환

CREATE INDEX device_status_h_ix
ON device_status_history
   (device_id, change_time DESC, change_seq DESC, history_id DESC);

SELECT /*+ INDEX_DESC(h device_status_h_ix) */ ...

FETCH FIRST 1 ROW ONLY

FETCH FIRST 1 ROW WITH TIES

전체 결과 Top-1 동률
→ WITH TIES

각 DEVICE_ID별 최신 시각 동률
→ PARTITION BY가 있는 DENSE_RANK

ASC  → NULLS LAST
DESC → NULLS FIRST

ORDER BY change_time DESC

ORDER BY change_time DESC NULLS LAST,
         change_seq DESC,
         history_id DESC

SELECT device_id,
       change_time,
       change_seq,
       status,
       history_id
FROM (
    SELECT h.*,
           ROW_NUMBER() OVER (
               PARTITION BY h.device_id
               ORDER BY h.change_time DESC NULLS LAST,
                        h.change_seq DESC,
                        h.history_id DESC
           ) AS rn
    FROM   device_status_history h
)
WHERE rn = 1;

DEVICE_ID별 Partition 생성
→ 각 Partition에서 최신 순서 부여
→ 첫 번째 행만 반환

ORDER BY change_time DESC
→ 같은 시각 행의 1번 미정

ORDER BY change_time DESC,
         change_seq DESC,
         history_id DESC
→ 전체 순서 확정

SELECT h.*,
       ROW_NUMBER() OVER (
           PARTITION BY device_id
           ORDER BY change_time DESC NULLS LAST,
                    change_seq DESC,
                    history_id DESC
       ) AS rn
FROM device_status_history h
QUALIFY rn = 1;

SELECT device_id,
       change_time,
       change_seq,
       status
FROM (
    SELECT h.*,
           ROW_NUMBER() OVER (
               PARTITION BY h.device_id
               ORDER BY h.change_time DESC NULLS LAST,
                        h.change_seq DESC,
                        h.history_id DESC
           ) AS rn
    FROM   device_status_history h
    WHERE  h.change_time <= :as_of
)
WHERE rn = 1;

기준 시점 이하로 Filter
→ Key별 최신 순위 계산

ORDER BY device_id;

SELECT device_id,
       change_time,
       change_seq,
       status,
       history_id
FROM (
    SELECT h.*,
           DENSE_RANK() OVER (
               PARTITION BY h.device_id
               ORDER BY h.change_time DESC NULLS LAST
           ) AS dr
    FROM   device_status_history h
)
WHERE dr = 1;

시간 10:00 → Rank 1, Rank 1
시간 09:00 → Rank 2

SELECT h.device_id,
       MAX(h.change_time) AS latest_change_time,
       MAX(h.change_seq) KEEP (
           DENSE_RANK LAST
           ORDER BY h.change_time NULLS FIRST,
                    h.change_seq,
                    h.history_id
       ) AS latest_change_seq,
       MAX(h.status) KEEP (
           DENSE_RANK LAST
           ORDER BY h.change_time NULLS FIRST,
                    h.change_seq,
                    h.history_id
       ) AS latest_status,
       MAX(h.history_id) KEEP (
           DENSE_RANK LAST
           ORDER BY h.change_time NULLS FIRST,
                    h.change_seq,
                    h.history_id
       ) AS latest_history_id
FROM   device_status_history h
GROUP BY h.device_id;

1. ORDER BY 기준으로 각 Group의 순위를 계산
2. DENSE_RANK LAST에 해당하는 행 집합 선택
3. 그 행 집합에서 MAX(status) 같은 Aggregate 계산

KEEP 순서
1. ORDER BY로 Rank 계산
2. FIRST 또는 LAST Rank 행 집합 선택
3. 선택 집합에 MAX·MIN·SUM·AVG·COUNT 등 Aggregate 적용

MAX(status) KEEP (
    DENSE_RANK LAST
    ORDER BY change_time ASC NULLS FIRST,
             change_seq ASC,
             history_id ASC
)

MAX(status) KEEP (
    DENSE_RANK FIRST
    ORDER BY change_time DESC NULLS LAST,
             change_seq DESC,
             history_id DESC
)

MAX(status) KEEP (
    DENSE_RANK LAST ORDER BY change_time, history_id
),
MAX(operator_id) KEEP (
    DENSE_RANK LAST ORDER BY change_time
)

SELECT device_id,
       MAX(change_time) AS latest_change_time,
       MAX(status)      AS latest_status
FROM   device_status_history
GROUP BY device_id;

최신 시각 행의 STATUS = READY
과거 행의 STATUS       = STOP
문자열 MAX(STATUS)     = STOP

최신 시각 + 과거 행의 상태

WITH latest_time AS (
    SELECT device_id,
           MAX(change_time) AS max_change_time
    FROM   device_status_history
    GROUP BY device_id
)
SELECT h.*
FROM   device_status_history h
JOIN   latest_time x
  ON   x.device_id      = h.device_id
 AND   x.max_change_time = h.change_time;

한 Key의 CHANGE_TIME이 전부 NULL
→ MAX(CHANGE_TIME) = NULL

x.max_change_time = h.change_time

ON x.device_id = h.device_id
AND (
       x.max_change_time = h.change_time
    OR (x.max_change_time IS NULL AND h.change_time IS NULL)
)

MAX(CHANGE_TIME)만 Join
→ 최신 시각의 모든 행

CHANGE_TIME + CHANGE_SEQ + HISTORY_ID로 전체 순서 결정
→ 최신 행 한 건

1. Key별 MAX(CHANGE_TIME)
2. 그 시각 Row에서 MAX(CHANGE_SEQ)
3. 그 시각·순번 Row에서 MAX(HISTORY_ID)
4. 전체 Key로 원본 Join

MAX(CHANGE_TIME)
MAX(CHANGE_SEQ)
MAX(HISTORY_ID)
→ 각각 독립 계산하면 실제 Row가 없는 복합 Key 가능

선별된 장비 20건
→ 장비별 최신 Index Probe 20회

장비 500,000건
→ 최신 Index Probe 최대 500,000회

WITH ranked_history AS (
    SELECT h.*,
           ROW_NUMBER() OVER (
               PARTITION BY h.device_id
               ORDER BY h.change_time DESC NULLS LAST,
                        h.change_seq DESC,
                        h.history_id DESC
           ) AS rn
    FROM   device_status_history h
)
SELECT d.device_id,
       d.device_name,
       h.change_time,
       h.status
FROM   device d
LEFT JOIN ranked_history h
  ON   h.device_id = d.device_id
 AND   h.rn = 1;

WITH ranked_history AS (
    SELECT h.*,
           ROW_NUMBER() OVER (
               PARTITION BY h.device_id
               ORDER BY h.change_time DESC NULLS LAST,
                        h.change_seq DESC,
                        h.history_id DESC
           ) AS rn
    FROM device_status_history h
    WHERE h.change_time <= :as_of
)
...
LEFT JOIN ranked_history h
  ON h.device_id = d.device_id
 AND h.rn = 1

1. 최신 한 건인지 최신 시각의 모든 행인지 정한다.
2. 기준 시점이 있는지 확인한다.
3. 전체 순서를 만드는 Tie-Breaker를 정의한다.
4. NULL 정렬 정책을 정한다.
5. 0건·1건·동률 데이터를 만들고 결과를 검증한다.
6. 소수 Key와 전체 Key 요구를 구분한다.
7. Top-1·ROW_NUMBER·KEEP 후보를 작성한다.
8. Starts·A-Rows·Buffers·Memory·TEMP와 첫 행·전체 Fetch 시간을 비교한다.
9. KEEP 식마다 동일한 전체 ORDER BY를 사용하는지 확인한다.
10. MAX 후 Join의 동률·NULL·복합 Key 일관성을 확인한다.
11. 이력이 없는 마스터 행의 보존 여부를 확인한다.
12. 최종 출력 순서는 바깥 ORDER BY로 보장한다.