⚡

컬럼 지향 저장과 MergeTree

최민석·2026-05-29

컬럼 지향 저장과 MergeTree

ClickHouse

🔍 ClickHouse 스터디 시리즈

개요

ClickHouse를 제대로 공부해보고자 시리즈를 시작합니다. 이 시리즈는 개념을 읽는 데 그치지 않고, 로컬에 직접 띄워 데이터를 적재하고 쿼리가 디스크를 얼마나 읽는지 측정하며 확인하는 것을 목표로 합니다. 본문에 등장하는 수치는 모두 실제 측정값입니다.

첫 글의 주제는 "ClickHouse는 왜 빠른가" 입니다. 답의 절반은 컬럼 지향 저장, 나머지 절반은 MergeTree의 정렬키에 있습니다.


OLAP과 OLTP는 목표가 다릅니다

MySQL 같은 OLTP 데이터베이스는 "주문 1건 조회/수정" 같은 트랜잭션을 빠르게 처리하도록 설계되었습니다. 반면 ClickHouse는 OLAP, 즉 "수천만 행을 훑어 집계"하는 분석 쿼리에 최적화되어 있습니다. 이 목표 차이가 저장 구조부터 인덱스까지 모든 설계를 가릅니다.

MySQL의 멘탈 모델을 그대로 가져오면 ClickHouse에서 계속 헷갈립니다. 가장 먼저 버려야 할 가정이 "행 단위로 저장된다"는 것입니다.


컬럼 지향 저장

전통적인 row-store는 한 행의 모든 컬럼을 붙여서 저장합니다.

[ts1, user1, click, KR, 120] [ts2, user2, view, US, 80] [ts3, ...] ...

컬럼 지향(columnar) 저장은 같은 컬럼끼리 모아서 저장합니다.

ts:       [ts1, ts2, ts3, ...]
user_id:  [user1, user2, user3, ...]
event:    [click, view, purchase, ...]
country:  [KR, US, JP, ...]

SELECT avg(duration_ms) 같은 쿼리는 duration_ms 컬럼만 필요합니다. 컬럼 지향이면 그 컬럼 파일 하나만 읽으면 되고, 나머지는 디스크에서 건드리지도 않습니다. row-store라면 필요 없는 컬럼까지 포함된 행 전체를 읽어야 합니다. 분석 쿼리에서 SELECT *가 특히 나쁜 이유가 여기에 있습니다.

ClickHouse는 이 구조를 파일 단위로 그대로 구현합니다. 테이블의 각 컬럼은 디스크에 별도 .bin 파일로 저장됩니다.


테이블을 만들고 5천만 행 넣기

먼저 Docker로 ClickHouse를 띄웁니다.

docker run -d --name ch \
  --ulimit nofile=262144:262144 \
  -p 8123:8123 -p 9000:9000 \
  clickhouse/clickhouse-server:25.3

docker exec -it ch clickhouse-client

이벤트 로그를 흉내 낸 테이블을 만듭니다.

CREATE TABLE events
(
    ts           DateTime,
    user_id      UInt32,
    event_type   LowCardinality(String),
    country      LowCardinality(String),
    duration_ms  UInt32
)
ENGINE = MergeTree
ORDER BY (event_type, ts);

numbers() 테이블 함수로 5천만 행을 합성해 넣습니다. numbers(N)은 0부터 N-1까지 정수 한 컬럼을 가진 가상 테이블로, 여기서는 "행을 5천만 개 만드는 생성기"로만 사용합니다.

INSERT INTO events
SELECT
    now() - toIntervalSecond(rand() % 31536000)        AS ts,
    rand() % 100000                                    AS user_id,
    ['click','view','purchase','login','logout'][(rand() % 5) + 1]  AS event_type,
    ['KR','US','JP','CN','DE','FR'][(rand() % 6) + 1]              AS country,
    rand() % 5000                                      AS duration_ms
FROM numbers(50000000);
0 rows in set. Elapsed: 5.616 sec. Processed 50.00 million rows, 400.00 MB
(8.90 million rows/s., 71.23 MB/s.)

5천만 행을 5.6초에 적재했습니다. 초당 약 890만 행입니다.


측정 1: 필요한 컬럼만 읽습니다

컬럼 지향이 정말 동작하는지 측정합니다. ClickHouse 클라이언트는 쿼리 끝에 처리한 행 수와 읽은 바이트를 출력합니다. 이 바이트를 비교하면 됩니다.

컬럼 하나만 집계합니다.

SELECT avg(duration_ms) FROM events;
-- Processed 50.00 million rows, 200.00 MB

컬럼 둘을 집계합니다.

SELECT avg(duration_ms), avg(user_id) FROM events;
-- Processed 50.00 million rows, 400.00 MB

행 수는 둘 다 5천만으로 같지만, 읽은 바이트는 200MB에서 400MB로 정확히 2배가 되었습니다. duration_ms와 user_id는 둘 다 UInt32(4바이트)이므로 5천만 × 4바이트 = 200MB, 컬럼이 하나 늘면 그만큼 더 읽습니다. 쿼리에 등장한 컬럼만 읽는다는 사실이 수치로 확인됩니다.


MergeTree와 정렬키

테이블 정의에서 ENGINE = MergeTree와 ORDER BY (event_type, ts)가 핵심입니다. MergeTree는 데이터를 ORDER BY로 지정한 키 순서대로 물리 정렬해서 저장합니다.

여기서 흔한 오해가 있습니다. ORDER BY는 MySQL의 PRIMARY KEY처럼 보이지만 유니크를 강제하지 않습니다. 단지 "디스크에 이 순서로 정렬해서 저장하라"는 지시이고, 이 정렬을 기반으로 sparse index가 만들어집니다.

ClickHouse는 모든 행을 인덱싱하지 않습니다. 정렬된 데이터를 8192행씩 묶은 granule 단위로 나누고, 각 granule의 첫 값만 인덱스에 기록합니다. 이 묶음 크기가 테이블 설정의 index_granularity = 8192입니다.

인덱스 엔트리 수=⌈50,000,0008192⌉≈6104\text{인덱스 엔트리 수} = \left\lceil \frac{50{,}000{,}000}{8192} \right\rceil \approx 6104

5천만 행이지만 인덱스 엔트리는 약 6,104개뿐입니다. MySQL의 B-tree가 모든 행을 인덱싱하는 것과 정반대입니다. 인덱스가 작으니 통째로 메모리에 상주할 수 있고, 쿼리는 이 인덱스로 "읽을 필요가 없는 granule"을 먼저 쳐낸 뒤, 후보 granule만 디스크에서 순차로 읽습니다.

granule 내부는 콕 집어 찾지 않고 8192행을 그대로 스캔합니다. 컬럼 데이터가 압축 블록 단위로 저장되어 어차피 블록을 통째로 풀어야 하고, 순차 읽기가 빠르기 때문입니다.

🌱 이 설계 때문에 ClickHouse는 단건 조회(WHERE user_id = 12345 하나 찾기)에 약합니다. 그 한 행을 위해 최소 8192행짜리 granule을 통째로 읽어야 하기 때문입니다. ClickHouse를 단건 키 조회 용도로 쓰면 안 되는 기술적 이유가 이것입니다.


MySQL B-Tree와 무엇이 다른가

두 엔진은 사실 같은 뿌리에서 출발합니다. 둘 다 정렬된 데이터 위에서 동작합니다. MySQL InnoDB의 기본키는 clustered index라서 데이터가 PK 순서로 정렬되어 저장되고, MergeTree도 ORDER BY 키 순서로 정렬해 저장합니다. 차이는 그 정렬된 데이터 위에 인덱스를 얼마나 촘촘하게 만드느냐에 있습니다.

B-Tree: 모든 키를 담는 dense index

InnoDB의 기본키는 B+Tree입니다. 모든 행의 키가 트리에 들어 있고, 루트에서 리프까지 몇 단계만 타고 내려가면 특정 행에 정확히 도달합니다. 단건 조회가 O(log⁡n)O(\log n)으로 빠른 이유입니다. 대신 행이 늘어나면 트리에 담기는 키도 그만큼 늘어나므로, 인덱스 크기가 데이터 크기에 비례해 커집니다.

graph TD R["루트 노드"] --> B1["중간 노드"] R --> B2["중간 노드"] B1 --> L1["리프: 행 키"] B1 --> L2["리프: 행 키"] B2 --> L3["리프: 행 키"] B2 --> L4["리프: 행 키"] L1 -.-> D["모든 행이 인덱스에 존재 (dense)"] L2 -.-> D L3 -.-> D L4 -.-> D

MergeTree: granule마다 하나만 찍는 sparse index

MergeTree는 정렬된 데이터를 8192행짜리 granule로 나누고, 각 granule의 시작 지점(mark)만 인덱스에 기록합니다. 인덱스는 트리가 아니라 정렬된 mark 배열입니다. 범위 조건이 들어오면 이 배열에서 시작·끝 granule을 이진 탐색으로 찾고, 그 사이 granule만 읽습니다.

graph TD I["Primary Index (정렬된 mark 배열)<br/>mark0 | mark1 | mark2 | mark3 | ..."] I --> G0["granule 0<br/>8192행"] I --> G1["granule 1<br/>8192행"] I --> G2["granule 2<br/>8192행"] I --> G3["granule 3<br/>8192행"] G0 -.-> N["granule당 mark 1개 (sparse)"] G1 -.-> N G2 -.-> N G3 -.-> N

정리하면

항목 InnoDB (B+Tree) MergeTree (sparse index)
인덱스 밀도 모든 행 (dense) granule당 1개 (8192행마다)
인덱스 크기 행 수에 비례해 커짐 행 수 ÷ 8192 (작아서 메모리 상주)
구조 균형 트리 (B+Tree) 정렬된 mark 배열
단건 조회 O(log⁡n)O(\log n), 강함 granule을 통째로 읽음, 약함
범위 스캔 리프 노드 순회 granule 단위 prune, 강함
데이터 정렬 clustered = PK 순 ORDER BY 키 순

💡 같은 "정렬된 데이터" 위에서, B+Tree는 모든 키를 dense하게 인덱싱해 단건 조회(OLTP)에 최적화했고, MergeTree는 granule당 하나만 sparse하게 찍어 범위 스캔(OLAP)에 최적화했습니다. 인덱스 밀도라는 한 가지 선택이 두 데이터베이스의 성격을 갈라놓은 셈입니다.


측정 2: 정렬키가 스캔량을 결정합니다

정렬키의 효과를 세 가지 필터로 비교합니다. 결과 건수는 셋 다 800만 대로 비슷하지만, 실제로 읽은 행 수는 자릿수가 다릅니다.

정렬키의 첫 번째 컬럼으로 필터링합니다.

SELECT count() FROM events WHERE event_type = 'purchase';
-- count: 9,999,463 / Processed 81.92 thousand rows

999만 건을 세야 하는데 8만 행만 읽었습니다. event_type이 정렬키 첫 컬럼이라 purchase 데이터가 디스크에 연속으로 뭉쳐 있고, 완전히 채워진 granule은 메타데이터로 카운트한 뒤 경계 granule(약 10개 × 8192 ≈ 8만 행)만 실제로 읽었기 때문입니다.

정렬키의 두 번째 컬럼으로 필터링합니다.

SELECT count() FROM events
WHERE ts > '2025-11-01' AND ts < '2026-01-01';
-- count: 8,343,811 / Processed 573.44 thousand rows

각 granule이 모든 컬럼의 min/max를 들고 있어서, ts 범위와 겹치지 않는 granule을 건너뜁니다. 첫 컬럼만큼 완벽하지는 않지만 57만 행으로 줄었습니다.

정렬키에 없는 컬럼으로 필터링합니다.

SELECT count() FROM events WHERE country = 'KR';
-- count: 8,331,972 / Processed 50.00 million rows

country는 정렬키가 아니라서 5천만 행을 전부 훑었습니다.

필터 컬럼 정렬키 위치 읽은 행 수
event_type = 'purchase' 1번째 81,920
ts BETWEEN ... 2번째 573,440
country = 'KR' 없음 50,000,000

쿼리가 어떤 granule을 읽고 어떤 granule을 건너뛰는지는 다음 흐름으로 정리됩니다.

graph LR Q["WHERE event_type = 'purchase'"] --> IDX["Sparse Index<br/>(약 6104 엔트리)"] IDX -->|"click granules"| S1["건너뜀"] IDX -->|"login / logout granules"| S2["건너뜀"] IDX -->|"purchase granules"| R["읽음 (~8만 행)"] IDX -->|"view granules"| S3["건너뜀"]

정렬키는 곧 "어떤 필터를 자주 쓸 것인가"에 대한 설계 결정입니다. 자주 거는 필터 컬럼을 ORDER BY 앞쪽에 두면 스캔량이 자릿수 단위로 줄어듭니다.

💡 흥미로운 점은 country = 'KR'이 5천만 행을 전부 읽고도 0.033초로 끝났다는 것입니다. 읽은 바이트는 50MB에 불과했습니다. 정렬키를 타지 못해도 컬럼 지향과 압축 덕분에 그럭저럭 빠릅니다. 다만 정렬키를 타면 자릿수가 달라집니다.


정리

이번 글에서 다룬 내용을 주제별로 짚어 봅니다.

① 컬럼 지향 저장

  • ClickHouse는 컬럼마다 별도 파일(.bin)로 저장합니다.
  • 그래서 쿼리에 등장한 컬럼만 읽고, 나머지는 디스크에서 건드리지 않습니다.
  • 측정: 컬럼 1개 집계는 200MB, 2개는 400MB로 읽는 양이 정확히 비례했습니다.

② MergeTree와 정렬키

  • ORDER BY 키 순서대로 데이터를 물리 정렬해서 저장합니다. (PK처럼 보이지만 유니크를 강제하지 않습니다.)
  • 8192행 단위 granule로 묶고, granule마다 하나의 mark만 sparse index에 기록합니다.
  • 덕분에 5천만 행이라도 인덱스 엔트리는 약 6,104개로 작아, 인덱스가 통째로 메모리에 상주합니다.

③ B-Tree와의 차이

  • 둘 다 정렬된 데이터 위에서 동작하지만, 인덱스 밀도가 다릅니다.
  • B+Tree는 모든 행을 dense하게 인덱싱해 단건 조회에 강합니다.
  • sparse index는 granule당 1개만 찍어 범위 스캔에 강한 대신 단건 조회에 약합니다.

④ 정렬키가 곧 성능

  • 같은 데이터, 같은 결과 건수라도 필터 컬럼이 정렬키의 어디에 있느냐에 따라 읽는 행 수가 8만 → 57만 → 5천만으로 갈렸습니다.
  • 자주 거는 필터 컬럼을 ORDER BY 앞쪽에 두는 것이 설계의 핵심입니다.

다음 글에서는 country = 'KR'이 50MB만 읽고 끝난 배경인 LowCardinality와 압축을 다룹니다. 같은 LowCardinality 컬럼인데도 정렬 여부에 따라 압축비가 1.8배와 213배로 갈리는 현상도 측정으로 확인해 봅니다.


TL;DR

  1. ClickHouse는 컬럼별로 파일을 나눠 저장하므로, 분석 쿼리가 필요한 컬럼만 읽어 빠릅니다.
  2. MergeTree는 ORDER BY로 데이터를 정렬해 저장하고 8192행 granule의 sparse index로 읽을 범위를 좁힙니다. B-Tree처럼 모든 행을 인덱싱하지 않습니다.
  3. 자주 쓰는 필터를 정렬키 앞에 두는 것이 성능을 가릅니다. 측정에서 스캔량이 8만 ~ 5천만 행으로 자릿수 차이가 났습니다.

관련 포스트