Column-oriented Store: What's The Benefit?
7분 소요
이번 글에서는 행(row) vs 열(column) 인메모리 저장 구조, 이를 구현하는 기술인 Apache Arrow Format, Parquet, Polars의 내부 동작, 데이터 수정 시 발생하는 실제 처리까지 상세하게 살펴봅니다.
Row-oriented vs Column-oriented

- Row-oriented (행 지향)
- 하나의 행이 연속 저장 → OLTP(트랜잭션)에 유리
- 한 행을 통째로 읽거나 수정할 때 효율적
- Column-oriented (열 지향)
- 컬럼별로 값들이 연속 저장 → OLAP(분석)에 유리
- 특정 컬럼만 빠르게 읽기, 고효율 압축, 벡터화 연산 가능
Review: Row-oriented (행 지향)
행 지향의 경우 하나의 행이 연속적으로 저장되는 형태로 데이터가 메모리에 존재하며 우리가 흔히 알고 있는 MySQL, PostgreSQL이 이와 같은 형태로 데이터가 저장됩니다.
# Row Table ex.) Memory
┌─────────┬───────────────────────────────┬───────────────────────────────┐
│ row id │ row buffer │ description │
├─────────┼───────────────────────────────┼───────────────────────────────┤
│ 0 │ [1, "Alice", 25, "Seoul"] │ row0: id, name, age, city │
│ 1 │ [2, "Bob", 30, "Busan"] │ row1: id, name, age, city │
│ 2 │ [3, "Carol", 27, "Seoul"] │ row2: id, name, age, city │
│ 3 │ [4, "David", 22, "Daegu"] │ row3: id, name, age, city │
└─────────┴───────────────────────────────┴───────────────────────────────┘
한 행의 모든 값(id, name, age, city)이 연속적으로 저장되며, 한 행 전체를 통째로 읽거나 쓰기는 OLTP 환경에서 유리합니다.
컬럼 기반 저장 포맷(Columnar Storage)이란?
데이터를 행 단위가 아닌 열 단위로 묶어서 저장하는 방식
이 방식은 데이터 분석이나 집계 연산처럼 특정 컬럼의 데이터만 읽어야 할 때 효율적이며, 같은 데이터 타입의 값들이 모여 있어 압축률이 높고 쿼리 속도를 향상시키는 장점이 있습니다.
# Table
| id | name | age | city |
| -- | ----- | --- | ----- |
| 1 | Alice | 25 | Seoul |
| 2 | Bob | 30 | Busan |
| 3 | Carol | 27 | Seoul |
예를 들어 다음과 같은 사용자 테이블이 있다면, Row-oriented는 [1, 'Alice', 25, 'Seoul'], [2, 'Bob', 30, 'Busan'], … 과 같이 저장되는 반면에 Column-oriented는 아래와 같이 데이터를 저장합니다.
id → [1, 2, 3], name → ['Alice', 'Bob', 'Carol'], age → [25, 30, 27], city → ['Seoul', 'Busan', 'Seoul']
이 방식은 특정 컬럼만 스캔하는 쿼리에서 성능 이점을 얻을 수 있습니다.
읽기 효율성(Read Optimization)
필요한 컬럼만 읽기 때문에 디스크에서 불필요한 데이터를 로드하지 않음
압축 효율 향상 (Compression)
같은 데이터 타입이 연속되어 있어 Run-Length Encoding (RLE), Dictionary Encoding 같은 압축이 잘 작동합니다.
region: [Seoul, Seoul, Seoul, Busan, Busan]
→ RLE: (Seoul × 3), (Busan × 2)
- Run-Length Encoding (RLE): 연속 반복 값(예: A × 100)을 짧게 표현 →
[A, A, A, A, B, B] → [(A,4),(B,2)] - Dictionary Encoding: 고유 값 목록을 인덱스로 치환 →
["Seoul", "Busan", "Seoul"] → [0,1,0]+ 사전["Seoul","Busan"] - Delta Encoding: 정수 시퀀스에서 이전 값과의 차이를 저장 →
[100,102,105] → [100,2,3] - Bit-Packing: 작은 비트 수로 여러 값을 밀집 저장
- 페이지 압축: 각 페이지를 Snappy/ZSTD 등으로 압축
벡터화(SIMD) & 캐시 국소성(Cache Locality)
컬럼 값이 연속되어 있으므로 CPU가 한 번에 여러 값을 캐시에 올려 처리할 수 있음
고정길이 값들이 연속 배열이므로 CPU의 SIMD 명령어로 한 번에 여러 값을 처리할 수 있습니다. ex.) 8개 int를 한 명령에 처리
또한 동일 컬럼 값이 메모리에 연속되어 존재하기 때문에, CPU L1/L2 캐시 히트율이 높습니다.
열지향 데이터 포맷 읽기
전체 파일을 읽지 않고 메타데이터 기반 최적화 가능
- 쿼리 수신 (SQL/DataFrame)
- 메타데이터 읽기 → 파일 레벨 프루닝
- 컬럼/RowGroup/페이지 선택
- 선택된 바이트 읽기 (디스크 → 메모리)
- 압축 해제 & 디코딩
- Arrow 메모리 구조로 올리기 (zero-copy 가능)
- 벡터화 연산 실행 (필터/집계/Join)
- 결과 직렬화/반환
Apache Arrow, Polars and Parquet
열지향 구조를 활용하는 데는 여러 가지 방법과 플랫폼, 포맷들이 있습니다. 그중 아래의 3가지를 소개하겠습니다.
- Apache Arrow: Columnar 구조를 위한 표준 포맷
- Apache Parquet: 디스크 저장용 Columnar Format
- Polars: Arrow 기반의 DataFrame 엔진
Apache Arrow — 인메모리 컬럼 포맷의 표준
메모리 상의 Columnar 구조를 위한 표준 포맷
서로 다른 데이터 인프라가 서로 간의 데이터 공유를 위해 API를 이용할 때 발생하는 문제점 중 하나는 직렬화와 역직렬화의 오버헤드가 너무 높다는 것인데요.
Arrow는 데이터를 메모리에 컬럼 단위로 저장하는 방법을 표준화하여, 플랫폼과 상관없이 메모리 상에서 컬럼 구조로 데이터를 정의하고, CPU와 GPU에서 메모리를 빠르게 읽고 쓸 수 있도록 합니다.

즉 하나의 시스템에서 Apache Arrow 포맷으로 데이터를 메모리에 로드하면 다른 시스템에서 해당 데이터를 로드할 때 데이터를 복사하는 것이 아닌 원본 데이터의 메모리 주소를 참조하는 방식(Zero-Copy)으로 동작합니다.
10GB의 파일을 메모리에 Apache Arrow 포맷으로 로드한 후 다른 시스템에서 해당 데이터를 사용하게 된다면 메모리 사용량은 10GB + 10GB가 아닌 여전히 10GB로 데이터의 메모리 주소만 다른 시스템에 전달된다.
Apache Parquet — 디스크 저장용 Columnar 포맷
Parquet은 Arrow의 디스크 버전
Documentation — The Apache Parquet Website
Parquet은 디스크 상에 컬럼 단위로 데이터를 압축 저장하는 포맷으로, 대부분의 데이터 레이크 시스템(Spark, Redshift, BigQuery 등)이 기본 지원합니다.
# Structure
Parquet file
├── File Footer (schema, stats)
├── RowGroup #1
│ ├── ColumnChunk: id
│ ├── ColumnChunk: name
│ └── ColumnChunk: age
└── RowGroup #2 ...
- RowGroup: 수천~수만 행 단위로 묶인 블록
- ColumnChunk: 컬럼별 데이터 묶음
- Statistics: min/max/null count → predicate pushdown에 활용
Polars — Arrow 기반의 DataFrame 엔진
Polars는 Arrow 포맷을 사용하는 차세대 DataFrame 엔진으로 Pandas, DuckDB 등과 동일한 역할을 수행할 수 있습니다.
Polars — DataFrames for the new era
Polars는 Rust로 작성된 DataFrame 엔진으로 내부 메모리 구조가 Arrow와 동일하며, Pandas보다 메모리 효율적이고 빠른 DataFrame 라이브러리입니다.
GB 단위의 데이터를 처리할 때 Spark의 단점과 Pandas의 단점을 잘 보완할 수 있습니다. ex.) Spark: 비용 효율성, Pandas: 병렬처리 미흡
import polars as pl
df = pl.DataFrame({
"id": [1, 2, 3],
"value": ["A", "B", "C"]
})
# Parquet 저장
df.write_parquet("data.parquet")
# Lazy Load
lazy_df = pl.scan_parquet("data.parquet")
result = (
lazy_df
.filter(pl.col("id") > 1)
.select("value")
.collect()
)
print("Lazy Result:")
print(result)
# Eager Load (즉시 읽기 후 처리)
df = pl.read_parquet("data.parquet")
# 조건 필터링
eager_result = df.filter(pl.col("id") > 1).select("value")
print("Eager Result:")
print(eager_result)
pl.scan_*()를 사용하여 lazy execution을 수행할 수 있으며, 이 경우 불필요한 연산은 pushdown 시킬 수 있습니다.
pl.read_*를 사용하여 즉시 읽기 후 처리할 수도 있습니다.
- Lazy Load:
scan_*→ 쿼리 계획만 생성 →.collect()호출 시 실제 데이터 읽고 처리. 이 경우 불필요한 연산은 pushdown 시킬 수 있음 - Eager Load:
read_*→ 파일을 바로 메모리로 읽음 → 즉시 DataFrame 연산 가능
두 방식 모두 동일한 결과지만, Lazy는 큰 데이터셋에서 I/O와 메모리 최적화를 할 수 있습니다.
Columnar Storage의 단점
모든 기술이 그렇듯 Columnar Storage에도 트레이드오프가 있습니다.
문제 1: 데이터 수정/삭제(Update/Delete)가 불가능 (Immutable)
Parquet, ORC, Arrow 기반 파일들은 immutable 구조를 가지며 한 번 파일을 쓰면, 기존 데이터를 직접 수정하는 in-place update가 불가능합니다.
만약 100만 건의 데이터가 저장된 Parquet 파일에서 단 1건의 행을 수정(UPDATE)하거나 삭제(DELETE)하려면, 해당 파일을 통째로 읽어들인 뒤, 수정/삭제된 내용을 반영한 새로운 Parquet 파일을 만들고 기존 파일은 삭제(하거나 덮어써야) 합니다.
문제 2: 작은 파일 문제 (Small File Problem)
데이터가 실시간으로 스트리밍되어 1분마다 100건씩 Parquet 파일로 저장된다면 한 시간에 6,000개의 Parquet 파일이 생기며, 이 경우 File I/O 오버헤드가 기하급수적으로 증가하여 쿼리 성능이 저하됩니다.
문제 3: ACID 트랜잭션 미지원
데이터 쓰기 작업(Job)이 중간에 실패하게 된다면, 일부 데이터는 쓰이고, 일부는 쓰이지 않은 ‘더티 데이터(Dirty Data)’ 상태가 될 수 있으며, 동시에 데이터를 읽고 쓸 때 데이터 일관성을 보장받을 수 없습니다.
Delta Lake + Compaction
Delta Lake는 Parquet 파일을 직접 수정하지 않고 Delta 파일을 생성하여 위에 발생하는 문제점들을 효율적으로 해결할 수 있습니다.

Delta Lake Structure
해결 1: 수정/삭제(UPDATE/DELETE)의 효율적 처리 (Copy-on-Write)
Delta log를 활용하여 원본 대용량 파일을 건드리지 않고도 트랜잭션 로그를 통해 논리적으로 데이터를 수정/삭제할 수 있게 됩니다.
- DELETE (삭제):
- 원본 Parquet 파일(A)은 그대로 둡니다.
_delta_log에 “파일 A의 특정 행은 삭제된 것으로 간주하라”고 기록합니다.
- UPDATE (수정): (내부적으로는 Delete + Insert)
_delta_log에 “파일 A의 특정 행은 삭제된 것으로 간주하라”고 기록합니다.- 수정된(새로운) 데이터를 별개의 작은 Parquet 파일(B) 로 씁니다.
_delta_log에 “파일 B가 새로 추가되었다”고 기록합니다.
해결 2: ‘Compaction’으로 작은 파일 문제 해결 (OPTIMIZE)
위의 1번(수정/삭제) 과정이나 스트리밍 데이터가 계속 쌓이면, 결국 작은 파일 문제가 다시 발생합니다. (수정 내역을 담은 작은 파일 B, C, D… 가 계속 생기므로)
이때 Compaction(압축)이 필요합니다. Delta Lake에서는 이 작업을 OPTIMIZE 명령어로 수행합니다.
- Compaction (OPTIMIZE)의 역할:
- Delta Lake 테이블을 구성하는 수백, 수천 개의 작은 Parquet 파일들을 읽어들입니다.
- 이 데이터들을 합쳐서 크고 최적화된 소수의 Parquet 파일(예: 1GB)로 다시 씁니다.
_delta_log에 “이제부터 작은 파일 A, B, C… 대신 큰 파일 Z를 사용하라”고 기록합니다.
쿼리 엔진이 읽어야 할 파일 수가 획기적으로 줄어들어, ‘작은 파일 문제’가 해결되고 쿼리 속도가 다시 빨라집니다.
해결 3: 트랜잭션 로그를 통한 ACID 보장
_delta_log는 데이터에 대한 모든 변경 사항(추가, 삭제, 수정, Compaction)을 원자적(Atomic)으로 기록합니다.- 데이터 쓰기 작업이 중간에 실패하면, 로그 파일 자체가 생성되지 않으므로(Commit 실패) 데이터는 이전의 일관된 상태를 유지합니다.
- 모든 리더(Reader)는 항상
_delta_log의 최신 버전을 참조하므로, 데이터 쓰기(Write)가 일어나는 중에도 일관성 있는 스냅샷을 읽을 수 있습니다(Isolation).