7151 words
36 minutes
[Trino]동적 필터와 파일 프루닝
  • 사람 한 명을 조회하는 쿼리에서 볼 수 있는 증상
    • 결과는 몇 행인데 스캔은 수십 GB, 셔플은 수천만 행
    • EXPLAIN에 dynamic filter가 분명히 보이는데 읽은 양이 그대로
    • 같은 조건을 리터럴로 쓰면 빠르고, 조인으로 쓰면 느림
  • 원인은 대체로 둘 중 하나
    • 동적 필터(DF)가 너무 늦게 도착함
    • DF는 제때 왔지만 파일 통계로 건너뛸 게 없음 (조회 키로 정렬되어 있지 않음)
  • 여기서 다루는 내용
    • Parquet이 건너뛰는 단위, Iceberg sort order
    • Trino 동적 필터의 동작과 도착 시점
    • optimize로 정렬할 때의 비용, 스냅샷, 동시 커밋
    • 느린 조인 패턴 5가지와 진단 방법

1. Parquet 에서 Pruning이 일어나는 단위#

Terminal window
data file (≈300~500MB)
└─ row group (기본 128MB)
└─ column chunk (컬럼 하나의 row group 몫)
└─ page (≈1MB)
  • row group 크기 : Iceberg write.parquet.row-group-size-bytes, Trino parquet_writer_block_size
  • footer 통계
    • row group마다 컬럼별 min/max, null 수
    • reader는 데이터를 읽기 전에 footer만 보고 phone = 'X'가 [min, max] 밖인 row group을 통째로 건너뜀
  • page index (column index + offset index)
    • page 단위 min/max
    • Trino는 parquet.use-column-index(기본 true)로 사용 → 정렬된 파일이면 row group 안에서도 page 단위로 건너뜀
  • bloom filter
    • column chunk마다 “이 값이 있을 수도 / 확실히 없다”를 답하는 비트맵
    • 정렬 없이도 등치(=, IN) 조회를 거를 수 있음
    • 범위 조회는 못 하고 파일이 조금 커짐

1.1 정렬이 왜 필요한가#

  • 조회 키(전화번호, 사용자 ID 등)가 무작위로 섞여 있으면 모든 row group의 min/max가 사실상 전체 범위를 덮음
    • 예 : 파일 2개 모두 lower_bound = '1', upper_bound = '9999995356'
    • → min/max로 걸러지는 게 하나도 없음
  • 정렬하면 row group·page마다 범위가 좁아져서 값 하나는 page 몇 개에만 걸림

min/max 통계는 데이터가 그 키로 모여 있을 때만 쓸모가 있다.


Concept

  • Row Group : Parquet 파일을 행 묶음으로 나눈 단위. 컬럼별 min/max 통계가 붙어 건너뛰기의 기본 단위가 됨
  • Page Index : page 단위 min/max를 담은 인덱스. 정렬된 파일에서 row group보다 더 잘게 건너뛸 수 있게 함
  • Min/Max Pruning : 통계 범위 밖의 블록을 읽지 않는 최적화. 데이터가 조회 키로 모여 있어야 효과가 있음
  • Bloom Filter : 값의 존재 여부를 확률적으로 답하는 비트맵. 거짓 음성이 없어 “확실히 없음”인 블록을 건너뛸 수 있음
  • Data Clustering : 같은 키 값을 가까운 위치에 모아 쓰는 것. 정렬이 대표적이며 통계 기반 프루닝의 전제 조건

2. Iceberg sort order#

  • sort order는 테이블 메타데이터에 저장되는 “앞으로 파일을 쓸 때 이 순서로 써라” 는 힌트
    • 기존 파일을 바꾸지 않음
    • 읽기 결과의 순서도 보장하지 않음
  • 데이터 파일마다 어떤 sort order로 쓰였는지 sort_order_id가 남음 → 정렬 진행 상황 확인용
-- 0 이면 정렬 없이 쓴 파일
SELECT partition, sort_order_id, count(*)
FROM iceberg.<schema>."<table>$files"
GROUP BY 1, 2 ORDER BY 1;
  • Trino sorted_by 테이블 속성 = Iceberg sort order
    • 같은 메타데이터를 바꾸므로 Trino에서 걸든 Spark에서 걸든 두 writer 모두에 적용됨

2.1 로컬 정렬 vs 전역 정렬#

구분의미결과
로컬 정렬 (local)각 writer task가 자기가 쓰는 파일 안에서만 정렬파일 하나는 정렬, 파일끼리는 범위가 겹침
전역 정렬 (range)먼저 키 범위로 셔플해 task마다 다른 구간을 맡긴 뒤 정렬파일끼리 범위가 안 겹쳐 파일 단위로도 건너뜀. 대신 셔플 비용
  • 압축 후 하루 파티션이 파일 1~2개라면 파일 단위 프루닝보다 파일 안의 row group·page 프루닝이 핵심 → 로컬 정렬로 충분
  • Trino
    • iceberg.sorted_writing_enabled = true(기본값)면 sort order가 있는 테이블에 쓸 때 writer마다 로컬 정렬
    • 메모리를 넘으면 임시 파일로 나눠 정렬한 뒤 병합
    • optimize도 이 writer로 씀
  • Spark (Iceberg DDL)
    • WRITE ORDERED BY col → 전역 정렬. write.distribution-mode를 range로 바꿈 → 쓰기마다 셔플 추가
    • WRITE LOCALLY ORDERED BY col → task 안에서만 정렬. 분산 모드는 그대로
    • 연산별 분산 모드(write.merge.distribution-mode 등)가 테이블 전체 값보다 우선 → MERGE 경로는 이 값까지 확인
  • 확인 방법 : Spark 실행 계획에 Sort는 생기고 Exchange는 생기지 않으면 로컬 정렬

Concept

  • Sort Order (Iceberg) : 앞으로 쓸 파일의 정렬 순서를 정하는 테이블 메타데이터. 기존 파일은 다시 써야 정렬됨
  • sort_order_id : 각 데이터 파일이 어떤 sort order로 쓰였는지 기록한 값. 정렬 적용 범위를 파일 단위로 추적할 수 있음
  • Local Sort : 셔플 없이 writer task 안에서만 정렬. 비용이 작고 파일 내부 프루닝에 충분
  • Range Distribution : 키 범위로 데이터를 재분배한 뒤 쓰는 방식. 파일 간 범위가 분리되지만 셔플 비용이 듦
  • Distribution Mode : Iceberg가 쓰기 전에 데이터를 어떻게 재분배할지 정하는 설정(none, hash, range). 연산별 설정이 우선함

3. 동적 필터(DF): 기초부터#

3.1 용어#

용어뜻
build 쪽hash join에서 먼저 다 읽어 메모리 해시 테이블로 만드는 작은 입력
probe 쪽hash join에서 한 행씩 읽어 해시 테이블과 비교하는 큰 입력
DF동적 필터. 실행 중에 build 쪽 결과로 만들어 probe 쪽 스캔에 보내는 조건
splitTrino 스캔의 작업 단위. 파일 하나 또는 파일의 한 구간
split source코디네이터에서 split 목록을 만드는 부분
page sourceworker에서 split 하나를 읽는 Parquet reader

3.2 DF가 없는 hash join#

select t.*
from events t -- probe 쪽: 1억 행
join members m on m.site_id = t.site_id
and m.member_id = t.user_id -- build 쪽: 회원 2명
  1. build 쪽(members)을 다 읽어 메모리에 해시 테이블 {(12,'kim01'), (45,'lee77')} 생성
  2. probe 쪽(events)을 한 행씩 읽어 해시 테이블과 비교
  3. 있으면 결과로, 없으면 버림
  • 1억 행을 모두 S3에서 읽고 모두 셔플함 → 결과는 몇 행
  • 비용의 대부분은 버릴 행을 읽고 셔플하는 데 듦

3.3 정적 필터와 동적 필터#

  • 정적 필터 : 값을 SQL에 직접 쓴 경우
where t.site_id in (12, 45) and t.user_id in ('kim01', 'lee77')
  • 계획 단계에서 값을 알기 때문에 스캔으로 내림(pushdown) → 파티션 값과 파일 통계로 건너뜀
  • 조인으로 쓰면 계획 단계에서 값을 모름. 아는 건 “t.user_id는 members.member_id 중 하나”라는 관계뿐
  • DF는 이 값을 실행 중에 정함
    1. 계획 : probe 쪽 스캔에 DF 자리(#df_388)를 만듦. 값은 비어 있음
    2. 수집(collection) : build 쪽이 끝나면 결과에서 DF 값 {kim01, lee77}을 모음 → 이 시간이 DF 수집 시간
    3. 전달 : DF 값을 probe 쪽 스캔에 보냄. 받은 뒤부터는 정적 필터와 같은 방법으로 씀
Terminal window
InnerJoin[criteria = (site_id = site_id_1, user_id = member_id),
dynamicFilterAssignments = {site_id_1 -> #df_387, member_id -> #df_388}] ← build 쪽에서 DF 값을 모으는 곳
ScanFilterProject[table = iceberg:<schema>.events ...,
dynamicFilters = {site_id = #df_387, user_id = #df_388}] ← probe 쪽 스캔에서 DF를 쓰는 곳

3.4 DF의 성질#

  • 조인 결과에 들어가지 않을 행만 버림 → 결과는 바뀌지 않고 비용만 줄임
  • inner join과 IN (select …)(semi join)에서 만들어짐
  • LEFT JOIN의 왼쪽(보존 쪽)에는 걸리지 않음 → 짝이 없는 왼쪽 행도 결과에 남기 때문
  • build 쪽 결과가 0건이면 DF 값은 NONE → probe 쪽은 아무것도 읽지 않아도 됨
  • build 쪽 distinct 값이 너무 많으면 min~max 범위로 줄이거나 DF를 만들지 않음

Concept

  • Build / Probe Side : hash join에서 해시 테이블을 만드는 입력과 그 테이블에 대고 비교하는 입력. 보통 작은 쪽이 build
  • Dynamic Filter : build 쪽 실행 결과로 probe 쪽 스캔을 거르는 런타임 조건. 결과는 같고 읽기·셔플 비용만 줄임
  • Predicate Pushdown : 필터를 데이터를 읽는 단계로 내리는 최적화. 정적 필터는 계획 단계에, DF는 실행 중에 내려감
  • DF Collection Time : build 쪽이 끝나 DF 값이 확정되기까지 걸린 시간. DF 효과를 판단하는 핵심 지표
  • NONE Domain : build 쪽 결과가 비어 어떤 값도 맞지 않는 DF. probe 쪽 스캔을 통째로 생략할 수 있음

4. DF는 “언제 도착했나”가 효과를 정함#

4.1 도착 단계별로 줄어드는 비용#

  • probe 쪽 스캔 순서 : split 목록 생성 → page source 열기 → 행 읽기 → 셔플
DF가 도착한 단계그 단계에서 하는 일줄어드는 비용
① split 생성 전파티션 값과 파일 min/max로 split을 아예 만들지 않음읽기와 셔플
② page source 열기 전row group·page min/max로 건너뜀건너뛴 row group의 읽기
③ 읽는 중읽은 행을 셔플 전에 버림셔플과 조인. 읽기는 그대로
④ 셔플 뒤없음. 조인이 행을 버림없음

4.2 늦게 받으면 되돌릴 수 없는 일#

  • build 쪽과 probe 쪽은 거의 동시에 시작하고, probe 쪽은 기본으로 DF를 오래 기다리지 않음
  • split source는 split을 만들면 바로 worker에 배정 → DF가 나중에 와도 이미 만든 split은 취소하지 않음
  • page source는 열 때 DF를 확인 → 이미 연 page source는 끝까지 읽음. 그 뒤엔 ③만 가능

4.3 dynamic_filtering_wait_timeout#

  • iceberg.dynamic_filtering_wait_timeout : split source가 split 생성을 시작하기 전에 DF를 기다리는 최대 시간 (기본 1초)
설정split 생성 시작DF 도착결과
기본 1초1초38초①·②를 놓침. 7천만 행 이상을 읽고 셔플
1m38초 (DF 받은 때)38초split 만들 때 DF가 NONE → split 0개, 스캔 0 bytes
  • 대기 시간을 늘려도 DF가 빨리 오지는 않음 → split 생성을 DF 도착 뒤로 미룰 뿐
  • 실측 : 해당 분기 단독 실행이 6분 이상 → 12초

4.4 결과가 작은 것 ≠ 실행이 빠른 것#

  • 사례의 build 쪽 결과는 0건 → DF로 probe 쪽 전체를 건너뛸 수 있는 상황
  • 그런데 build 쪽 계산에 38초 → 파티션 없는 차원 테이블을 다 읽고 행마다 regexp_replace 실행
  • 결과가 작으면 DF 효과가 크고, 실행이 느리면 DF가 늦게 옴 → 둘이 같이 있을 때 대기 시간 설정이 가장 효과적

4.5 기다려도 쿼리 전체가 거의 늦어지지 않는 이유#

  1. 조인은 build 쪽이 끝나기 전에는 결과를 한 행도 만들지 못함
  2. probe 쪽을 일찍 읽어도 그 행들은 조인 앞에서 기다릴 뿐
  3. 추가로 드는 시간은 “build 쪽이 끝난 뒤 probe 쪽을 읽는 시간”
  4. DF가 probe 쪽을 많이 거르면 그 시간은 짧음 (사례에선 split 0개라 거의 0)
  5. 오히려 미리 읽던 probe 쪽이 클러스터 CPU를 써서 build 쪽을 느리게 했을 수 있음 (확인하진 않음)

4.6 대기 시간을 늘리면 손해인 경우#

  • DF가 거르는 행이 적을 때 : build 쪽이 수백만 명이고 probe 쪽 대부분과 맞으면 동시 실행 이득만 잃음
  • build 쪽이 대기 시간보다 오래 걸릴 때 : 시간이 지나면 DF 없이 split을 만듦 → 기본값과 같은 문제 + 기다린 시간도 손해
  • 그래서
    • 대기 시간은 예상 DF 수집 시간보다 길게
    • 클러스터 기본값은 1초로 두고, build 쪽 결과가 작은 쿼리에만 SET SESSION으로 늘림

4.7 다른 해결 방법#

  • build 쪽을 1초 안에 끝나게 만듦 → 기본값으로도 제때 도착
  • DF 대신 리터럴 조건 → 계획 단계에서 값을 알아 도착 시점 문제가 없음 (단, 미리 알 수 없는 값엔 불가)

4.8 사례: 파일이 적으면 늦은 DF가 쓸모없어짐#

Terminal window
시간 → 0s 1s 38s
build 쪽 [차원 테이블 전체 스캔 + regexp_replace ...]────────────┐
결과 0건 → DF = NONE
split [DF 대기]│
source └─ 1초 지남 → DF 없이 split 약 80개(파일 27개) 생성 → 목록 완성
worker [page source 열기 → 읽기 → 셔플 .................]
→ 38초 전에 연 split을 끝까지 읽음 → 7천만 행 이상 셔플 → 조인이 모두 버림
  • 압축이 끝난 테이블이라 하루 파일 1개 → split 목록이 바로 다 만들어짐
  • 파일이 수천 개였다면 목록 생성이 오래 걸려 늦은 DF도 남은 split을 ①에서 건너뛸 수 있었을 것
  • 압축(compaction)이 잘 된 테이블일수록 DF 도착 시점에 더 민감함

4.9 사례: DF는 제때 왔는데 다 읽음#

  • DF 값(전화번호 하나)이 제때 도착해 119개 split에 적용됐는데도 8GB를 다 읽음
  • 파일이 그 키로 정렬되어 있지 않아 row group min/max가 거의 전체 범위 → ②에서 건너뛸 게 없고 ③만 적용
  • 스캔을 줄이려면 두 조건이 모두 필요
    1. DF가 page source를 열기 전에 도착 → 대기 시간 설정
    2. 파일 통계로 DF 값이 없는 row group을 알 수 있음 → 정렬 또는 bloom filter

4.10 직접 해 보기#

-- A. 기본값(1초). 없는 값을 써서 build 쪽 결과를 0건으로 만듦
EXPLAIN ANALYZE VERBOSE
with members as (
select distinct site_id, member_id
from iceberg.<schema>.dim_user
where regexp_replace(cellphone, '[^0-9]', '') = '01000000000'
)
select count(*)
from iceberg.<schema>.events t
join members m on m.site_id = t.site_id and m.member_id = t.user_id
where t.dt between '20261001' and '20261027';
-- B. 대기 시간을 늘린 뒤 A를 다시 실행
SET SESSION iceberg.dynamic_filtering_wait_timeout = '1m';
-- C. 리터럴 조건. DF가 필요 없음
EXPLAIN ANALYZE
select count(*) from iceberg.<schema>.events t
where t.dt between '20261001' and '20261027'
and t.site_id = 12 and t.user_id = 'kim01';
  • 비교할 항목
    • probe 쪽 스캔 노드의 Input: N rows (X GB)
    • dynamic filter의 domain(NONE)과 수집 시간 (/v1/query/{id}의 queryStats.dynamicFiltersStats)
  • build 쪽이 단순하면 1초 안에 끝나 A도 0 bytes가 될 수 있음 → build 쪽에 조인을 하나 더 붙여 느리게 만들어 보면 차이가 보임

Concept

  • Split Enumeration : 코디네이터가 스캔할 split 목록을 만드는 단계. 여기서 DF를 적용하면 읽기와 셔플이 모두 사라짐
  • Late-Arriving Filter : 스캔이 이미 시작된 뒤 도착한 런타임 필터. 읽은 행을 버리는 것만 가능해 효과가 작음
  • Wait Timeout Trade-off : DF를 기다리면 스캔을 줄일 수 있지만 build/probe 동시 실행 이득을 잃음. DF 수집 시간과 선택도로 판단
  • Selectivity : 필터가 남기는 행의 비율. 선택도가 높을(남는 행이 적을)수록 DF를 기다릴 가치가 큼
  • Static vs Runtime Predicate : 계획 단계에 아는 조건과 실행 중에 정해지는 조건. 리터럴로 바꿀 수 있으면 타이밍 문제 자체가 사라짐

5. optimize로 과거 파일 정렬하기#

5.1 optimize가 실제로 하는 일#

ALTER TABLE <table> EXECUTE optimize(file_size_threshold => 'X') [WHERE …];
  • WHERE에 맞는 파티션에서 크기가 X보다 작은 파일만 골라 합쳐 다시 씀
  • 다시 쓸 때 현재 sort order를 따름
  • 함정 : 일상 압축(threshold 128MB)은 이미 300~500MB가 된 과거 파일을 건드리지 않음
    • 과거 파일까지 정렬하려면 threshold를 가장 큰 파일보다 크게(예 : 2GB) 잡아야 함
  • WHERE는 파티션으로 딱 떨어지는 조건이어야 함
    • day(ts) 파티션은 UTC 자정 경계로 써야 함
    • KST 자정으로 쓰면 하루가 반쪽씩 걸쳐 거부되거나 의도와 다르게 동작
  • 쓰기 증폭 : 전체 200GB면 200GB를 읽고 다시 씀 → 월 단위 등 창으로 나누면 실패해도 그 창만 다시 하면 됨

5.2 스냅샷과 저장 공간#

  • optimize는 기존 파일을 지우지 않음 → “옛 파일 대신 새 파일”이라는 replace 스냅샷만 커밋
  • 옛 파일은 이전 스냅샷(time travel)이 계속 참조
  • expire_snapshots가 그 스냅샷을 만료시킨 뒤에야 지워짐 → 그전까지 다시 쓴 범위만큼 저장 공간 2배
  • 창을 나누고 만료 주기에 맞춰 진행
  • remove_orphan_files가 꺼져 있으면 커밋에 실패한 rewrite가 남긴 고아 파일은 자동으로 정리되지 않음

5.3 동시 커밋 (optimize ↔ 주기적 MERGE)#

  • Iceberg는 낙관적 동시성
    • 각 writer가 기준 스냅샷 위에서 작업하고, 커밋할 때 그사이 생긴 스냅샷과 충돌하는지 검증
    • 충돌이 없으면 메타데이터를 다시 얹어(rebase) 커밋
  • optimize(replace)는 “내가 바꾸려는 원본 파일이 그사이 지워지지 않았는지”를 검증
    • MERGE가 WHEN NOT MATCHED THEN INSERT만 있으면 파일을 추가만 함 → 이 검증에 안 걸림
  • MERGE 쪽은 “그사이 내 조건에 맞는 파일이 새로 추가됐는지”를 검증
    • append·overwrite 스냅샷만 보고 replace(압축) 스냅샷은 보지 않는 것으로 이해 → 충돌 가능성 낮음
    • 첫 회차엔 MERGE 로그에서 ValidationException·재시도가 없는지 확인
  • 계속 바뀌는 당일 파티션은 rewrite 범위에서 빼는 게 안전

5.4 정렬 비용은 어디서 드나#

경로추가 비용크기
주기적 MERGE (Spark)배치 안 로컬 정렬배치가 작아 작음
일상 optimize (Trino)전날 파일을 정렬해서 쓰기하루치
과거분 rewrite정한 범위 전체를 읽고 정렬해 다시 쓰기범위에 비례
읽기없음키 조회만 빨라지고 날짜 범위 집계는 그대로

Concept

  • Bin-Packing Compaction : 작은 파일을 목표 크기로 합치는 압축. 크기 기준만 보므로 이미 큰 파일은 다시 쓰지 않음
  • Sort Rewrite : sort order에 맞춰 기존 파일을 다시 쓰는 작업. threshold와 WHERE로 범위를 명시적으로 잡아야 함
  • Write Amplification : 논리적으로 바뀐 양보다 훨씬 많이 다시 쓰는 현상. 창을 나눠 실패 범위와 비용을 제한함
  • Replace Snapshot : 파일 집합을 다른 파일 집합으로 바꾸는 커밋. 데이터 내용은 같고 물리 배치만 바뀜
  • Optimistic Concurrency : 락 없이 작업하고 커밋 시점에 충돌을 검증하는 방식. 충돌 조건이 겹치지 않으면 동시 작업이 가능함
  • Partition-Aligned Predicate : 파티션 경계와 정확히 맞는 조건. 파티션 변환(day, month)이 UTC 기준이면 경계도 UTC로 써야 함

6. 느린 조인의 흔한 패턴과 알아보는 법#

6.1 DF가 늦게 도착하는 조건#

  • 대부분의 BI 조인은 build 쪽(차원 테이블을 속성으로 거른 결과)이 작고 빨라 DF가 제때 옴
  • 아래가 겹치면 늦게 옴
    1. build 쪽 결과는 작지만 계산이 무거움 (큰 테이블을 거쳐 사람 몇 명을 찾는 서브쿼리)
    2. probe 쪽 파일 수가 적음 (압축된 테이블은 split 목록이 바로 만들어짐)
    3. CTE나 조인이 여러 단계로 이어짐
    4. 클러스터가 바쁘거나 같은 쿼리의 다른 분기와 자원을 나눠 씀
  • 사람 단위 조회(ID 하나로 여러 시스템 조회)는 거의 항상 1·2번에 해당

6.2 패턴 목록#

번호패턴예해결
P1파티션 프루닝 실패. 파티션 조건이 JOIN ON 안에 있거나, 다른 테이블 값을 참조하거나, 파티션 컬럼에 함수가 걸림날짜 조건이 LEFT JOIN ON 안에서 다른 테이블을 참조 → 3.9억 행을 읽음리터럴 조건으로 씀
P2DF가 늦게 도착DF NONE이 38초에 도착 → 7천만 행 이상 셔플dynamic_filtering_wait_timeout을 수집 시간보다 길게
P3DF가 안 만들어지거나 스캔에 안 내려감. LEFT JOIN 보존 쪽, 조인 키에 함수·cast, 키 타입 불일치조인 키가 regexp_replace(d.cellphone, …) → 3,400만 행을 읽고 그대로 내보냄. 이 스캔이 P2의 build 쪽을 느리게 함조인 키를 컬럼 그대로 씀. 변환이 필요하면 build 쪽 값을 변환
P4DF는 왔지만 건너뛴 게 없음. 조회 키로 정렬 안 됨DF를 119개 split에 적용했는데 8GB를 다 읽음. 파일 min/max가 전체 범위정렬 또는 bloom filter
P5큰 중간 결과를 만든 뒤 마지막에 자름9천만 행에 left join 후 TopN사람·기간을 먼저 한정, TopN을 먼저. 자주 쓰면 모델로 만듦
  • 가장 흔한 건 P4로 봄 → 레이크 테이블은 대부분 날짜 파티션만 있고 사람·ID 같은 조회 키로는 정렬되어 있지 않음

6.3 알아보는 법#

1단계 : 쿼리 정보를 바로 저장

  • Trino는 끝난 쿼리 정보를 일정 시간 뒤 지움 → 그 뒤 조회하면 410 Gone
  • 느린 쿼리는 끝난 직후에 저장
Terminal window
curl -s -u "$TRINO_USER:$TRINO_PASSWORD" \
"http://$TRINO_HOST:$TRINO_PORT/v1/query/<query_id>" > q.json

2단계 : 테이블별 스캔과 DF를 한 번에 봄

# 사용법: python3 qinfo.py q.json
import json, sys
d = json.load(open(sys.argv[1]))
qs = d['queryStats']
print(d['queryId'], d['state'], qs['elapsedTime'], 'CPU', qs['totalCpuTime'], 'input', qs['physicalInputDataSize'])
tables = {} # planNodeId → 테이블 이름
def walk(n):
t = n.get('descriptor', {}).get('table')
if t: tables[n['id']] = t.split('$')[0]
for c in n.get('children', []): walk(c)
for s in d['stages']['stages']:
walk(json.loads(s['plan']['jsonRepresentation']))
print('\n[테이블별 스캔] 읽은 행 · 읽은 크기 · DF 적용 split 수 · 내보낸 행')
agg = {}
for o in qs['operatorSummaries']:
if o['operatorType'] in ('TableScanOperator', 'ScanFilterAndProjectOperator'):
a = agg.setdefault(o['planNodeId'], [0, 0, 0, 0])
a[0] += o['physicalInputPositions']; a[1] += int(o['physicalInputDataSize'].rstrip('B'))
a[2] += o['dynamicFilterSplitsProcessed']; a[3] += o['outputPositions']
for nid, (rows, size, dfs, out) in sorted(agg.items(), key=lambda x: -x[1][1]):
print(f"{tables.get(nid, nid):60s} {rows:>13,} {size/1e9:8.2f}GB DF split {dfs:>5} out {out:>13,}")
print('\n[DF] id · 수집 시간 · 값')
for f in qs['dynamicFiltersStats']['dynamicFilterDomainStats']:
print(f"{f['dynamicFilterId']:10s} {f.get('collectionDuration', '-'):>9s} {f['simplifiedDomain'][:90]}")
  • 출력 예
Terminal window
iceberg:<schema>.request_log 102,584,300 8.16GB DF split 119 out 96,455,148 ← P4
iceberg:<schema>.send_history 390,027,809 3.49GB DF split 0 out 390,027,809 ← P1
iceberg:<schema>.dim_user_a 20,970,365 0.47GB DF split 0 out 1
iceberg:<schema>.dim_user_b 34,378,341 0.36GB DF split 0 out 34,378,341 ← P3
...
df_3320 28.38s [ SortedRangeSet[type=varchar, ranges=1, {[821020001395]}] ]
df_3332 38.10s NONE ← P2

3단계 : 출력으로 패턴을 판정

보이는 것의심할 패턴다음에 확인할 것
큰 테이블의 읽은 행 = 내보낸 행, DF split 0P1 또는 P3필터가 스캔에 내려갔는지
읽은 크기 > 기간 파티션 크기P1$files로 기대 크기 계산
DF 수집 시간 > 1초 이고 그 DF를 쓰는 probe 쪽이 큼P2대기 시간을 늘려 재실행
DF split > 0 인데 읽은 크기 = 기간 전체 크기P4파일 min/max, sort_order_id
최종 출력은 작은데 중간 stage 출력이 수천만 행P5TopN 아래 노드의 입력 행 수
  • “DF 수집 시간이 길다”만으로는 문제가 아님 → 그 DF를 쓰는 probe 쪽이 작으면 영향이 작음. 수집 시간과 probe 쪽 읽은 크기를 같이 봄

4단계 : 패턴별 확인

-- P1. 기대 크기 = 기간 파티션의 파일 크기 합. 2단계의 읽은 크기와 비교
SELECT count(*) AS files, sum(file_size_in_bytes) / 1e9 AS gb
FROM iceberg.<schema>."<table>$files"
WHERE partition.dt BETWEEN '20261001' AND '20261027';
-- P1. 스캔에 내려간 조건. inputTableColumnInfos[].constraint.columnConstraints에
-- 파티션 컬럼 범위가 있어야 함. 없으면 프루닝되지 않음
EXPLAIN (TYPE IO, FORMAT JSON) <쿼리>;
  • P2 : 2단계 출력의 DF 수집 시간보다 대기 시간을 길게 설정하고 재실행 → probe 쪽 읽은 크기가 줄면 P2
  • P3 : EXPLAIN에서 probe 쪽 ScanFilterProject에 dynamicFilters = {…}가 있는지 확인. 없으면 조인 조건에서 찾음
    • LEFT JOIN 보존 쪽에 있는 테이블
    • 조인 키의 함수·cast : regexp_replace(d.cellphone, …) = p.cellphone, cast(t.id as varchar) = u.id
    • 두 키의 타입이 달라 Trino가 cast를 자동으로 넣는 경우
-- P4. 0 이면 정렬 없이 쓴 파일
SELECT sort_order_id, count(*) FROM iceberg.<schema>."<table>$files" GROUP BY 1;
-- P4. 파일별 조회 키 min/max. 파일마다 거의 전체 범위면 건너뛸 수 없음
SELECT file_size_in_bytes,
json_extract_scalar(readable_metrics, '$.<key>.lower_bound') AS lo,
json_extract_scalar(readable_metrics, '$.<key>.upper_bound') AS hi
FROM iceberg.<schema>."<table>$files"
WHERE partition.dt = DATE '2026-10-20';
  • $files는 파일 단위 min/max만 보여 줌. row group 단위는 Parquet footer에 있음
  • 파일 단위 범위가 이미 전체면 정렬되지 않은 것이므로 row group 단위도 대부분 전체 범위로 봄

6.4 대응 기준#

  1. 가끔 도는 사람 단위 조회 : 쿼리 맨 위에 SET SESSION iceberg.dynamic_filtering_wait_timeout. P1은 리터럴로 고침
  2. 자주 도는 사람 단위 조회 : DF 설정에 의존하지 않음 → 사람 키로 미리 정리한 테이블을 만듦
  3. 조회 키가 정해진 큰 테이블 : 정렬 또는 bloom filter 검토

Concept

  • Partition Pruning Failure : 파티션 조건이 스캔에 내려가지 않아 전체 파티션을 읽는 현상. JOIN ON 안의 조건, 다른 테이블 참조, 파티션 컬럼의 함수가 흔한 원인
  • Non-Sargable Join Key : 함수나 cast가 걸려 필터를 컬럼에 직접 적용할 수 없는 조인 키. DF가 스캔에 내려가지 못함
  • Late Limit : 큰 중간 결과를 다 만든 뒤 마지막에 자르는 실행. 한정 조건과 TopN을 앞으로 당겨야 함
  • Query Info Retention : 코디네이터가 끝난 쿼리 정보를 보관하는 시간. 지나면 410 Gone이라 진단 정보는 바로 저장해야 함
  • Physical Input vs Output Rows : 스캔이 읽은 행과 내보낸 행의 비교. 둘이 같으면 스캔 단계에서 아무 필터도 적용되지 않은 것

Key takeaways#

  1. “결과가 작다”와 “읽은 게 작다”는 다른 문제
    • DF는 결과를 바꾸지 않고 비용만 줄이며, 그 효과는 도착 시점과 파일 통계 두 가지에 달림
  2. DF는 언제 도착했는지가 전부
    • split 생성 전에 오면 읽기·셔플이 사라지고, 읽는 중에 오면 셔플만 줄고, 셔플 뒤면 아무 효과 없음
    • 이미 만든 split, 이미 연 page source는 되돌리지 않음
  3. 대기 시간은 DF를 빨리 오게 하지 않고 스캔을 늦게 시작하게 할 뿐
    • build 결과가 작고 계산은 느린 쿼리에서만 이득. 수집 시간보다 짧으면 기다린 시간까지 손해
  4. 압축이 잘 된 테이블일수록 DF 타이밍에 민감함
    • 파일이 적으면 split 목록이 순식간에 완성돼 늦게 온 DF가 끼어들 틈이 없음
  5. min/max 통계는 데이터가 그 키로 모여 있을 때만 쓸모 있음
    • 날짜 파티션만 있는 레이크 테이블에서 사람·ID 조회는 대부분 이 문제(P4)
  6. sort order는 강제가 아니라 힌트
    • 걸어도 기존 파일은 그대로. sort_order_id로 진행 상황을 보고, 과거분은 threshold를 크게 잡은 optimize로 다시 써야 함
  7. 로컬 정렬로 충분한 경우가 많음
    • 파티션당 파일이 적으면 파일 간 범위 분리보다 파일 안 row group·page 프루닝이 핵심. 전역 정렬은 셔플 비용
  8. rewrite는 공짜가 아님
    • 다시 쓴 범위만큼 쓰기 증폭, 스냅샷 만료 전까지 저장 공간 2배. 창을 나눠 진행
  9. 파티션 경계 조건은 파티션 변환의 시간대를 따름
    • day() 파티션이면 UTC 자정으로 써야 함
  10. 리터럴로 쓸 수 있으면 리터럴로
    • 계획 단계에 값을 알면 타이밍 문제 자체가 사라짐. JOIN ON 안의 파티션 조건은 프루닝을 깨뜨림
  11. 조인 키에 함수를 걸지 않음
    • DF가 스캔에 못 내려가고, 그 스캔이 다른 DF의 build 쪽을 느리게 만드는 연쇄가 생김
  12. 진단 정보는 바로 저장
    • 쿼리 정보는 곧 사라짐. 테이블별 읽은 행·크기·DF 적용 split·내보낸 행과 DF 수집 시간을 한 화면에서 보면 패턴이 바로 보임

추가적으로 공부하면 좋은 컨셉, 주제들#

  • Parquet Bloom Filter 설정 : Iceberg write.parquet.bloom-filter-enabled.column.*, FPP와 파일 크기 트레이드오프
  • Z-order / Hilbert Curve 정렬 : 여러 키로 동시에 프루닝하기 위한 다차원 클러스터링
  • Iceberg Rewrite Data Files 전략 : binpack, sort, zorder 전략의 차이
  • Trino Cost-Based Optimizer : join reordering, broadcast vs partitioned join 선택과 통계의 역할
  • Runtime Filter in Spark : Spark의 Dynamic Partition Pruning, bloom filter join과 Trino DF 비교
  • Iceberg Commit Conflict Validation : 연산별(append, overwrite, replace, row-delta) 충돌 검증 범위

참고 자료#

  • Trino Iceberg connector : sorted_by, optimize, sorted_writing_enabled, dynamic_filtering_wait_timeout, $files 메타데이터 테이블
  • Trino Dynamic filtering 문서
  • Iceberg Spark DDL : ALTER TABLE … WRITE ORDERED BY / LOCALLY ORDERED BY / DISTRIBUTED BY
  • Iceberg 쓰기 속성 : write.distribution-mode, write.merge.distribution-mode, write.parquet.row-group-size-bytes, write.parquet.bloom-filter-enabled.column.*
  • Iceberg 유지보수 : rewrite data files, expire snapshots
  • Parquet 포맷 : row group statistics, page index, bloom filter
[Trino]동적 필터와 파일 프루닝
https://yjinheon.netlify.app/posts/02de/03-spark/trino-dynamic-filter-pruning/
Author
Datamind
Published at
2026-11-06
License
CC BY-NC-SA 4.0