7151 words
36 minutes
[Trino]동적 필터와 파일 프루닝
- 사람 한 명을 조회하는 쿼리에서 볼 수 있는 증상
- 결과는 몇 행인데 스캔은 수십 GB, 셔플은 수천만 행
EXPLAIN에 dynamic filter가 분명히 보이는데 읽은 양이 그대로- 같은 조건을 리터럴로 쓰면 빠르고, 조인으로 쓰면 느림
- 원인은 대체로 둘 중 하나
- 동적 필터(DF)가 너무 늦게 도착함
- DF는 제때 왔지만 파일 통계로 건너뛸 게 없음 (조회 키로 정렬되어 있지 않음)
- 여기서 다루는 내용
- Parquet이 건너뛰는 단위, Iceberg sort order
- Trino 동적 필터의 동작과 도착 시점
- optimize로 정렬할 때의 비용, 스냅샷, 동시 커밋
- 느린 조인 패턴 5가지와 진단 방법
1. Parquet 에서 Pruning이 일어나는 단위
data file (≈300~500MB) └─ row group (기본 128MB) └─ column chunk (컬럼 하나의 row group 몫) └─ page (≈1MB)- row group 크기 : Iceberg
write.parquet.row-group-size-bytes, Trinoparquet_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로 걸러지는 게 하나도 없음
- 예 : 파일 2개 모두
- 정렬하면 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 쪽 스캔에 보내는 조건 |
| split | Trino 스캔의 작업 단위. 파일 하나 또는 파일의 한 구간 |
| split source | 코디네이터에서 split 목록을 만드는 부분 |
| page source | worker에서 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명- build 쪽(
members)을 다 읽어 메모리에 해시 테이블{(12,'kim01'), (45,'lee77')}생성 - probe 쪽(
events)을 한 행씩 읽어 해시 테이블과 비교 - 있으면 결과로, 없으면 버림
- 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는 이 값을 실행 중에 정함
- 계획 : probe 쪽 스캔에 DF 자리(
#df_388)를 만듦. 값은 비어 있음 - 수집(collection) : build 쪽이 끝나면 결과에서 DF 값
{kim01, lee77}을 모음 → 이 시간이 DF 수집 시간 - 전달 : DF 값을 probe 쪽 스캔에 보냄. 받은 뒤부터는 정적 필터와 같은 방법으로 씀
- 계획 : probe 쪽 스캔에 DF 자리(
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천만 행 이상을 읽고 셔플 |
1m | 38초 (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 기다려도 쿼리 전체가 거의 늦어지지 않는 이유
- 조인은 build 쪽이 끝나기 전에는 결과를 한 행도 만들지 못함
- probe 쪽을 일찍 읽어도 그 행들은 조인 앞에서 기다릴 뿐
- 추가로 드는 시간은 “build 쪽이 끝난 뒤 probe 쪽을 읽는 시간”
- DF가 probe 쪽을 많이 거르면 그 시간은 짧음 (사례에선 split 0개라 거의 0)
- 오히려 미리 읽던 probe 쪽이 클러스터 CPU를 써서 build 쪽을 느리게 했을 수 있음 (확인하진 않음)
4.6 대기 시간을 늘리면 손해인 경우
- DF가 거르는 행이 적을 때 : build 쪽이 수백만 명이고 probe 쪽 대부분과 맞으면 동시 실행 이득만 잃음
- build 쪽이 대기 시간보다 오래 걸릴 때 : 시간이 지나면 DF 없이 split을 만듦 → 기본값과 같은 문제 + 기다린 시간도 손해
- 그래서
- 대기 시간은 예상 DF 수집 시간보다 길게
- 클러스터 기본값은 1초로 두고, build 쪽 결과가 작은 쿼리에만
SET SESSION으로 늘림
4.7 다른 해결 방법
- build 쪽을 1초 안에 끝나게 만듦 → 기본값으로도 제때 도착
- DF 대신 리터럴 조건 → 계획 단계에서 값을 알아 도착 시점 문제가 없음 (단, 미리 알 수 없는 값엔 불가)
4.8 사례: 파일이 적으면 늦은 DF가 쓸모없어짐
시간 → 0s 1s 38sbuild 쪽 [차원 테이블 전체 스캔 + regexp_replace ...]────────────┐ 결과 0건 → DF = NONEsplit [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가 거의 전체 범위 → ②에서 건너뛸 게 없고 ③만 적용
- 스캔을 줄이려면 두 조건이 모두 필요
- DF가 page source를 열기 전에 도착 → 대기 시간 설정
- 파일 통계로 DF 값이 없는 row group을 알 수 있음 → 정렬 또는 bloom filter
4.10 직접 해 보기
-- A. 기본값(1초). 없는 값을 써서 build 쪽 결과를 0건으로 만듦EXPLAIN ANALYZE VERBOSEwith 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 tjoin members m on m.site_id = t.site_id and m.member_id = t.user_idwhere t.dt between '20261001' and '20261027';
-- B. 대기 시간을 늘린 뒤 A를 다시 실행SET SESSION iceberg.dynamic_filtering_wait_timeout = '1m';
-- C. 리터럴 조건. DF가 필요 없음EXPLAIN ANALYZEselect count(*) from iceberg.<schema>.events twhere 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)
- probe 쪽 스캔 노드의
- 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가
- 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가 제때 옴
- 아래가 겹치면 늦게 옴
- build 쪽 결과는 작지만 계산이 무거움 (큰 테이블을 거쳐 사람 몇 명을 찾는 서브쿼리)
- probe 쪽 파일 수가 적음 (압축된 테이블은 split 목록이 바로 만들어짐)
- CTE나 조인이 여러 단계로 이어짐
- 클러스터가 바쁘거나 같은 쿼리의 다른 분기와 자원을 나눠 씀
- 사람 단위 조회(ID 하나로 여러 시스템 조회)는 거의 항상 1·2번에 해당
6.2 패턴 목록
| 번호 | 패턴 | 예 | 해결 |
|---|---|---|---|
| P1 | 파티션 프루닝 실패. 파티션 조건이 JOIN ON 안에 있거나, 다른 테이블 값을 참조하거나, 파티션 컬럼에 함수가 걸림 | 날짜 조건이 LEFT JOIN ON 안에서 다른 테이블을 참조 → 3.9억 행을 읽음 | 리터럴 조건으로 씀 |
| P2 | DF가 늦게 도착 | DF NONE이 38초에 도착 → 7천만 행 이상 셔플 | dynamic_filtering_wait_timeout을 수집 시간보다 길게 |
| P3 | DF가 안 만들어지거나 스캔에 안 내려감. LEFT JOIN 보존 쪽, 조인 키에 함수·cast, 키 타입 불일치 | 조인 키가 regexp_replace(d.cellphone, …) → 3,400만 행을 읽고 그대로 내보냄. 이 스캔이 P2의 build 쪽을 느리게 함 | 조인 키를 컬럼 그대로 씀. 변환이 필요하면 build 쪽 값을 변환 |
| P4 | DF는 왔지만 건너뛴 게 없음. 조회 키로 정렬 안 됨 | DF를 119개 split에 적용했는데 8GB를 다 읽음. 파일 min/max가 전체 범위 | 정렬 또는 bloom filter |
| P5 | 큰 중간 결과를 만든 뒤 마지막에 자름 | 9천만 행에 left join 후 TopN | 사람·기간을 먼저 한정, TopN을 먼저. 자주 쓰면 모델로 만듦 |
- 가장 흔한 건 P4로 봄 → 레이크 테이블은 대부분 날짜 파티션만 있고 사람·ID 같은 조회 키로는 정렬되어 있지 않음
6.3 알아보는 법
1단계 : 쿼리 정보를 바로 저장
- Trino는 끝난 쿼리 정보를 일정 시간 뒤 지움 → 그 뒤 조회하면
410 Gone - 느린 쿼리는 끝난 직후에 저장
curl -s -u "$TRINO_USER:$TRINO_PASSWORD" \ "http://$TRINO_HOST:$TRINO_PORT/v1/query/<query_id>" > q.json2단계 : 테이블별 스캔과 DF를 한 번에 봄
# 사용법: python3 qinfo.py q.jsonimport json, sysd = 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]}")- 출력 예
iceberg:<schema>.request_log 102,584,300 8.16GB DF split 119 out 96,455,148 ← P4iceberg:<schema>.send_history 390,027,809 3.49GB DF split 0 out 390,027,809 ← P1iceberg:<schema>.dim_user_a 20,970,365 0.47GB DF split 0 out 1iceberg:<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 ← P23단계 : 출력으로 패턴을 판정
| 보이는 것 | 의심할 패턴 | 다음에 확인할 것 |
|---|---|---|
| 큰 테이블의 읽은 행 = 내보낸 행, DF split 0 | P1 또는 P3 | 필터가 스캔에 내려갔는지 |
| 읽은 크기 > 기간 파티션 크기 | P1 | $files로 기대 크기 계산 |
| DF 수집 시간 > 1초 이고 그 DF를 쓰는 probe 쪽이 큼 | P2 | 대기 시간을 늘려 재실행 |
| DF split > 0 인데 읽은 크기 = 기간 전체 크기 | P4 | 파일 min/max, sort_order_id |
| 최종 출력은 작은데 중간 stage 출력이 수천만 행 | P5 | TopN 아래 노드의 입력 행 수 |
- “DF 수집 시간이 길다”만으로는 문제가 아님 → 그 DF를 쓰는 probe 쪽이 작으면 영향이 작음. 수집 시간과 probe 쪽 읽은 크기를 같이 봄
4단계 : 패턴별 확인
-- P1. 기대 크기 = 기간 파티션의 파일 크기 합. 2단계의 읽은 크기와 비교SELECT count(*) AS files, sum(file_size_in_bytes) / 1e9 AS gbFROM 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 hiFROM iceberg.<schema>."<table>$files"WHERE partition.dt = DATE '2026-10-20';$files는 파일 단위 min/max만 보여 줌. row group 단위는 Parquet footer에 있음- 파일 단위 범위가 이미 전체면 정렬되지 않은 것이므로 row group 단위도 대부분 전체 범위로 봄
6.4 대응 기준
- 가끔 도는 사람 단위 조회 : 쿼리 맨 위에
SET SESSION iceberg.dynamic_filtering_wait_timeout. P1은 리터럴로 고침 - 자주 도는 사람 단위 조회 : DF 설정에 의존하지 않음 → 사람 키로 미리 정리한 테이블을 만듦
- 조회 키가 정해진 큰 테이블 : 정렬 또는 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
- “결과가 작다”와 “읽은 게 작다”는 다른 문제
- DF는 결과를 바꾸지 않고 비용만 줄이며, 그 효과는 도착 시점과 파일 통계 두 가지에 달림
- DF는 언제 도착했는지가 전부
- split 생성 전에 오면 읽기·셔플이 사라지고, 읽는 중에 오면 셔플만 줄고, 셔플 뒤면 아무 효과 없음
- 이미 만든 split, 이미 연 page source는 되돌리지 않음
- 대기 시간은 DF를 빨리 오게 하지 않고 스캔을 늦게 시작하게 할 뿐
- build 결과가 작고 계산은 느린 쿼리에서만 이득. 수집 시간보다 짧으면 기다린 시간까지 손해
- 압축이 잘 된 테이블일수록 DF 타이밍에 민감함
- 파일이 적으면 split 목록이 순식간에 완성돼 늦게 온 DF가 끼어들 틈이 없음
- min/max 통계는 데이터가 그 키로 모여 있을 때만 쓸모 있음
- 날짜 파티션만 있는 레이크 테이블에서 사람·ID 조회는 대부분 이 문제(P4)
- sort order는 강제가 아니라 힌트
- 걸어도 기존 파일은 그대로.
sort_order_id로 진행 상황을 보고, 과거분은 threshold를 크게 잡은 optimize로 다시 써야 함
- 걸어도 기존 파일은 그대로.
- 로컬 정렬로 충분한 경우가 많음
- 파티션당 파일이 적으면 파일 간 범위 분리보다 파일 안 row group·page 프루닝이 핵심. 전역 정렬은 셔플 비용
- rewrite는 공짜가 아님
- 다시 쓴 범위만큼 쓰기 증폭, 스냅샷 만료 전까지 저장 공간 2배. 창을 나눠 진행
- 파티션 경계 조건은 파티션 변환의 시간대를 따름
day()파티션이면 UTC 자정으로 써야 함
- 리터럴로 쓸 수 있으면 리터럴로
- 계획 단계에 값을 알면 타이밍 문제 자체가 사라짐. JOIN ON 안의 파티션 조건은 프루닝을 깨뜨림
- 조인 키에 함수를 걸지 않음
- DF가 스캔에 못 내려가고, 그 스캔이 다른 DF의 build 쪽을 느리게 만드는 연쇄가 생김
- 진단 정보는 바로 저장
- 쿼리 정보는 곧 사라짐. 테이블별 읽은 행·크기·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/