seon99il

Data Engineering

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 캐시 히트율이 높습니다.

열지향 데이터 포맷 읽기

전체 파일을 읽지 않고 메타데이터 기반 최적화 가능

  1. 쿼리 수신 (SQL/DataFrame)
  2. 메타데이터 읽기 → 파일 레벨 프루닝
  3. 컬럼/RowGroup/페이지 선택
  4. 선택된 바이트 읽기 (디스크 → 메모리)
  5. 압축 해제 & 디코딩
  6. Arrow 메모리 구조로 올리기 (zero-copy 가능)
  7. 벡터화 연산 실행 (필터/집계/Join)
  8. 결과 직렬화/반환

Apache Arrow, Polars and Parquet

열지향 구조를 활용하는 데는 여러 가지 방법과 플랫폼, 포맷들이 있습니다. 그중 아래의 3가지를 소개하겠습니다.

  • Apache Arrow: Columnar 구조를 위한 표준 포맷
  • Apache Parquet: 디스크 저장용 Columnar Format
  • Polars: Arrow 기반의 DataFrame 엔진

Apache Arrow — 인메모리 컬럼 포맷의 표준

메모리 상의 Columnar 구조를 위한 표준 포맷

Apache Arrow — The universal columnar format and multi-language toolbox for fast data interchange and in-memory analytics

서로 다른 데이터 인프라가 서로 간의 데이터 공유를 위해 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

Home | Delta Lake — Delta Lake is an open-source storage framework that enables building a format agnostic Lakehouse architecture with…

해결 1: 수정/삭제(UPDATE/DELETE)의 효율적 처리 (Copy-on-Write)

Delta log를 활용하여 원본 대용량 파일을 건드리지 않고도 트랜잭션 로그를 통해 논리적으로 데이터를 수정/삭제할 수 있게 됩니다.

  • DELETE (삭제):
    1. 원본 Parquet 파일(A)은 그대로 둡니다.
    2. _delta_log에 “파일 A의 특정 행은 삭제된 것으로 간주하라”고 기록합니다.
  • UPDATE (수정): (내부적으로는 Delete + Insert)
    1. _delta_log에 “파일 A의 특정 행은 삭제된 것으로 간주하라”고 기록합니다.
    2. 수정된(새로운) 데이터를 별개의 작은 Parquet 파일(B) 로 씁니다.
    3. _delta_log에 “파일 B가 새로 추가되었다”고 기록합니다.

해결 2: ‘Compaction’으로 작은 파일 문제 해결 (OPTIMIZE)

위의 1번(수정/삭제) 과정이나 스트리밍 데이터가 계속 쌓이면, 결국 작은 파일 문제가 다시 발생합니다. (수정 내역을 담은 작은 파일 B, C, D… 가 계속 생기므로)

이때 Compaction(압축)이 필요합니다. Delta Lake에서는 이 작업을 OPTIMIZE 명령어로 수행합니다.

  • Compaction (OPTIMIZE)의 역할:
    1. Delta Lake 테이블을 구성하는 수백, 수천 개의 작은 Parquet 파일들을 읽어들입니다.
    2. 이 데이터들을 합쳐서 크고 최적화된 소수의 Parquet 파일(예: 1GB)로 다시 씁니다.
    3. _delta_log에 “이제부터 작은 파일 A, B, C… 대신 큰 파일 Z를 사용하라”고 기록합니다.

쿼리 엔진이 읽어야 할 파일 수가 획기적으로 줄어들어, ‘작은 파일 문제’가 해결되고 쿼리 속도가 다시 빨라집니다.

해결 3: 트랜잭션 로그를 통한 ACID 보장

  1. _delta_log는 데이터에 대한 모든 변경 사항(추가, 삭제, 수정, Compaction)을 원자적(Atomic)으로 기록합니다.
  2. 데이터 쓰기 작업이 중간에 실패하면, 로그 파일 자체가 생성되지 않으므로(Commit 실패) 데이터는 이전의 일관된 상태를 유지합니다.
  3. 모든 리더(Reader)는 항상 _delta_log의 최신 버전을 참조하므로, 데이터 쓰기(Write)가 일어나는 중에도 일관성 있는 스냅샷을 읽을 수 있습니다(Isolation).

이전 글

전체 글 보기 →

댓글