seon99il

This post is not translated yet, so it is shown in Korean.

Architecture

그때 우리가 알던 값: 시간에 따라 변하는 데이터를 모델링하는 법

15 min read

시간에 따라 변하는 데이터는 처음에는 별 문제가 없어 보입니다. 값이 바뀌면 UPDATE 하고, 이력이 필요하면 히스토리 테이블을 하나 붙이면 됩니다. 문제는 이런 질문이 들어오는 순간부터입니다.

“2월 급여가 왜 300만 원으로 나갔죠? 지금 시스템에서 보면 2월 월급은 320만 원인데요.”

시스템이 틀린 걸까요? 아닙니다. 2월 25일 급여를 돌릴 때 시스템이 알던 월급은 300만 원이 맞았습니다. 2월 15일부로 인상됐다는 사실은 3월 15일에야 들어왔으니까요. 이 질문에 답하지 못하는 이유는 데이터가 틀려서가 아니라, “2월의 월급”과 “2월에 우리가 알던 월급”을 같은 칸에 저장했기 때문입니다.

이 글은 Martin Fowler의 Temporal Patterns와 Bitemporal History를 읽고, 이런 데이터를 실제로 설계할 때 어떤 순서로 판단하면 좋을지 정리한 것입니다. 패턴 소개보다는 “어떤 결정을 어떤 근거로 내리나”에 초점을 맞췄습니다.

글 전체에서 예시 하나를 계속 씁니다.

  • 1월 1일: 직원 A의 월급 300만 원
  • 2월 25일: 300만 원으로 2월 급여 지급
  • 3월 15일: 인사팀 통보, “2월 15일부로 320만 원으로 인상됐어야 했다”
  • 3월 25일: 3월 급여와 함께 2월 차액 지급
  • 4월 5일: 재통보, “죄송합니다, 320만 원이 아니라 315만 원입니다”

1. 질문부터 분류한다

설계를 시작하기 전에, 이 데이터에 대해 사람들이 던질 질문이 어떤 모양인지부터 봐야 합니다. 시간이 들어간 질문은 거의 항상 이 셋 중 하나입니다.

질문필요한 날짜예시
지금 값은?없음A의 현재 월급
그날의 값은? (지금 아는 바로)1개2월 25일 A의 월급 → 315만 원
그날의 값을, 그때는 뭘로 알았나?2개2월 25일 A의 월급을 2월 25일에는 → 300만 원

세 번째 질문이 날짜를 두 개 품고 있다는 게 핵심입니다. 하나는 그 값이 현실에서 유효했던 시점, 다른 하나는 우리가 그 사실을 알고 있던 시점입니다. 이 둘을 각각 축으로 놓으면 다음과 같습니다.

  • 실제 시간(actual time, valid time): 현실에서 그 값이 유효했던 시점. A의 인상은 2월 15일.
  • 기록 시간(record time, transaction time): 시스템이 그 사실을 기록한 시점. A의 인상은 3월 15일.

두 축을 모두 저장하는 모델을 bi-temporal이라고 부릅니다. 이름은 문헌마다 다릅니다. SQL:2011 표준과 학계는 valid time/transaction time을, Fowler는 actual/record를 씁니다. 저는 팀에서 이름을 정할 때 valid_*와 recorded_*를 쓰는 편인데, 중요한 건 이름보다 한 팀 안에서 두 축을 절대 섞어 부르지 않는 것입니다.

예시를 표로 펼치면 같은 “2월 25일 월급”이 언제 묻느냐에 따라 세 가지 값이 됩니다.

기록 시점 (언제 기준으로)실제 시점 (어느 날의 월급)월급
2월 25일2월 25일300만 원
3월 20일2월 25일320만 원
4월 25일2월 25일315만 원

이 데이터를 읽는 방향도 두 가지입니다.

flowchart LR
    subgraph H["기록 시간 고정 = 그때 알던 실제 이력"]
        direction LR
        h["4월 25일 기준<br/>1/1~2/14 300만 → 2/15~ 315만"]
    end
    subgraph V["실제 시간 고정 = 그날 값에 대한 앎의 변화"]
        direction LR
        v["2월 25일 월급<br/>~3/14 300만 → 3/15~ 320만 → 4/5~ 315만"]
    end

4월 25일 기준 실제 이력에는 320만 원이 아예 등장하지 않습니다. 한 번도 사실이었던 적이 없는 값이니까요. 그런데 3월 25일에 차액을 320만 원 기준으로 정산했다면, 그 정산이 왜 그 금액이었는지는 오른쪽 방향으로 읽어야만 설명됩니다.

요구사항 정리 단계에서 “이 데이터에 대해 세 번째 질문을 하는 사람이 있는가?”를 꼭 확인하세요. 감사, 세무, 정산, 규제 보고, ML 학습 데이터의 point-in-time 정합성 같은 키워드가 나오면 대개 있습니다.

2. 두 축이 필요해도, 일단 피할 방법을 찾는다

세 번째 질문이 있다고 해서 바로 bi-temporal 테이블을 만들 필요는 없습니다. 두 축을 모델에 다 넣으면 모든 조회와 테스트에 날짜가 두 개씩 붙고, 무엇보다 이 데이터를 쓰는 사람들이 두 축을 이해해야 합니다. 시스템을 만드는 것보다 사람을 이해시키는 게 더 어렵습니다. 그래서 먼저 우회로를 찾습니다.

소급 변경을 정책으로 막는다. “변경은 통보가 도착한 날부터 적용한다”고 정하면 실제 시간이 기록 시간과 같아지고 축이 하나로 줄어듭니다. 보험이나 통신 요금제처럼 정책으로 정할 수 있는 도메인이라면 가장 싸게 끝나는 방법입니다. 기술 문제를 기획 회의에서 푸는 셈이죠.

행동이 자기 입력을 기록하게 한다. 급여 명세서를 만들 때 “어떤 월급 값을 근거로 계산했는지”를 명세서에 같이 저장하면, “그때 왜 300만 원이었나”는 명세서를 보면 답이 나옵니다. 월급 테이블 자체는 실제 시간 한 축이면 충분하고, 기록 시간은 계산 결과 안에 묻혀 있게 됩니다. 실무에서는 이 방법이 가장 자주 통합니다. 세 번째 질문의 대부분은 사실 “그 계산은 왜 그렇게 나왔나”이기 때문입니다.

정정이 그 값을 쓰는 행동보다 먼저 오게 한다. 인상 소식을 2월 24일에 받았다면 2월 급여는 맞게 나가고, 어긋날 일이 없습니다. 입력 마감을 앞당기거나, 배치를 영업일 마감 이후에만 돌리는 식의 운영 규칙이 여기에 해당합니다.

flowchart TD
    Q1{"'그때 알던 값'을<br/>묻는 사람이 있나?"}
    Q1 -- 아니오 --> ONE["실제 시간 한 축"]
    Q1 -- 예 --> Q2{"소급 변경을<br/>정책으로 막을 수 있나?"}
    Q2 -- 예 --> ONE
    Q2 -- 아니오 --> Q3{"질문이 결국<br/>'이 계산은 왜 이렇게 나왔나'인가?"}
    Q3 -- 예 --> TRACE["실제 시간 한 축<br/>+ 계산 결과에 입력값 기록"]
    Q3 -- 아니오 --> Q4{"정정이 잦고<br/>임의 시점 재현이 필요한가?"}
    Q4 -- 아니오 --> LOG["실제 시간 한 축<br/>+ 두 날짜를 남기는 변경 로그"]
    Q4 -- 예 --> BT["bi-temporal"]

어느 길로 가든 공통으로 지킬 것이 하나 있습니다. 변경 로그에는 실제 날짜와 기록 날짜를 둘 다 남기세요. 99%는 두 날짜가 같겠지만, 기록 날짜는 그 순간이 지나면 다시 만들어 낼 방법이 없습니다. 지금 당장 한 축만 쓰더라도, 로그에 두 날짜가 있으면 나중에 bi-temporal이 필요해졌을 때 과거를 복원할 재료가 남습니다.

3. 시간을 모델의 어디에 넣을지 정한다

축을 정했으면, 다음은 시간을 모델의 어느 단위에 붙일지입니다. 가벼운 것부터 순서대로 놓으면 이렇습니다.

flowchart LR
    AL["변경 로그<br/>(Audit Log)"] --> EF["Effectivity<br/>객체에 기간"]
    EF --> TP["Temporal Property<br/>속성 단위"]
    TP --> TO["Temporal Object<br/>객체 전체를 버전으로"]
    TP -.-> SN["Snapshot<br/>시점 고정 뷰"]
    TO -.-> SN

변경 로그: 다시 읽을 일이 드물 때

무엇이 언제 바뀌었는지 남기기만 하고, 가끔 사람이 들여다보는 정도라면 로그로 충분합니다. 쓰기는 거의 공짜입니다. 대신 읽기가 비쌉니다. 매주 과거 값을 조합해서 리포트를 만들어야 한다면 로그를 뒤지는 코드는 금방 느려지고 유지보수가 어려워집니다. 과거 값을 읽는 일이 업무 흐름 안으로 들어오면 모델로 끌어올릴 때입니다.

로그는 다른 방식과 섞어 쓸 수 있다는 점도 기억해 둘 만합니다. 실제 시간 이력은 모델에, 기록 시간 이력은 로그에 맡기는 식의 분업이 꽤 실용적입니다.

Effectivity: 기간 자체가 도메인 개념일 때

고용 계약, 프로모션, 요금제처럼 “특정 기간에만 유효한 것”이 도메인에서 명시적으로 이야기된다면 객체에 기간을 붙입니다. 이때 시작일과 종료일을 따로 들고 다니지 말고 기간을 값 객체로 만듭니다.

public record DateRange(LocalDate start, LocalDate end) { // [start, end)
    public static DateRange startingOn(LocalDate start) {
        return new DateRange(start, LocalDate.MAX);
    }
    public boolean includes(LocalDate date) {
        return !date.isBefore(start) && date.isBefore(end);
    }
}

단점은 시간이 겉으로 드러난다는 겁니다. 이 객체를 쓰는 모든 코드가 기간 조건을 신경 써야 하고, “현재 유효한 고용”을 찾으려고 여기저기서 루프를 돌게 됩니다. 그 루프를 한곳으로 모으고 싶어지면 다음 단계로 넘어갈 신호입니다.

Temporal Property: 몇몇 속성만 시간에 따라 변할 때

주소나 월급처럼 일부 속성만 시간에 따라 변한다면, 그 속성의 접근자가 날짜를 받게 만듭니다. 바깥에서는 평범한 속성처럼 보이고, 날짜를 안 주면 오늘 기준으로 동작합니다.

public class TemporalCollection<T> {
    private final TreeMap<LocalDate, T> contents = new TreeMap<>();

    public T get(LocalDate when) {
        var entry = contents.floorEntry(when); // when과 같거나 이전 중 가장 늦은 시점
        if (entry == null) throw new IllegalArgumentException("no record that early");
        return entry.getValue();
    }
    public T get() { return get(Clock.today()); }

    public void put(LocalDate from, T value) { contents.put(from, value); }
}

class Employee {
    private final TemporalCollection<Money> salary = new TemporalCollection<>();

    public Money salary()               { return salary.get(); }
    public Money salaryAt(LocalDate on) { return salary.get(on); }
    public void raise(LocalDate from, Money value) { salary.put(from, value); }
}

이 방식의 장점은 리팩터링이 쉽다는 겁니다. 일반 필드를 시간 컬렉션으로 바꾸고 기존 접근자는 그대로 두면 됩니다. 처음부터 모든 속성을 시간화하지 말고, 이력이 실제로 필요해진 속성부터 하나씩 옮기면 됩니다.

Temporal Object: 객체 전체가 버전으로 변할 때

대부분의 속성이 함께 바뀌거나, 비즈니스가 버전 자체를 가리켜 말한다면 객체 전체를 버전으로 다룹니다. “2차 개정 계약”, “v3 약관”처럼 사람들이 버전에 이름을 붙여 부르기 시작하면, 시간에 따라 바뀌는 속성이 하나뿐이어도 버전을 모델에 두는 게 맞습니다. 가리킬 대상이 모델에 있어야 하니까요.

이때 역할을 둘로 나눕니다.

  • 연속성(continuity): 버전이 바뀌어도 “그 계약”으로 남는 것. 거의 데이터 없이 정체성과 버전 목록만 갖습니다.
  • 버전(version): 특정 기간 동안의 상태 전체.
classDiagram
    direction LR
    class Contract["Contract (연속성)"] {
        contractNo
        +terms() 현재 버전에 위임
        +termsAt(date)
    }
    class ContractVersion["ContractVersion (버전)"] {
        DateRange effective
        rate
        terms
    }
    Contract *-- "*" ContractVersion

관계형 DB로 내리면 연속성 테이블 없이 버전 테이블만 두고, 계약 번호와 시작일을 묶어 키로 쓰는 경우가 많습니다. 뒤에서 볼 SCD Type 2가 정확히 이 모양입니다.

Snapshot: 한 시점에서 질문을 많이 할 때

“4월 1일 기준으로 이 고객에 대해” 질문을 열 개 해야 한다면, 매번 날짜를 넘기는 건 번거롭고 실수하기도 쉽습니다. 시점을 한 번 고정하고, 시간 개념을 걷어낸 뷰를 만들어 넘깁니다. 시간을 모르는 외부 시스템이나 리포트 템플릿에 데이터를 넘길 때 특히 유용합니다.

record EmployeeSnapshot(Employee base, LocalDate on) {
    Money salary() { return base.salaryAt(on); }
}

정리하면 판단 기준은 이렇습니다.

상황선택
기록만 하고 다시 읽을 일이 드물다변경 로그
“특정 기간에만 유효한 것”이 도메인 용어다Effectivity
일부 속성만 변하고, 그 값을 쉽게 꺼내야 한다Temporal Property
대부분 속성이 함께 변하거나, 비즈니스가 버전을 부른다Temporal Object
한 시점 기준으로 질문이 많거나, 시간을 모르는 쪽에 넘긴다위 방식 + Snapshot

4. 두 축은 갱신 규칙이 다르다

bi-temporal을 하기로 했다면, 설계에서 가장 중요한 사실은 두 축이 서로 다르게 움직인다는 점입니다.

  • 실제 이력은 고쳐집니다. 소급 변경이란 결국 과거의 실제 값을 바꾸는 일입니다. 2월 15일 이후의 월급은 300 → 320 → 315로 두 번 고쳐졌습니다.
  • 기록 이력은 append-only입니다. “3월 20일 기준으로 우리는 2월 월급을 320만 원으로 알았다”는 사실은 4월 5일에 정정이 들어와도 여전히 사실입니다. 과거에 우리가 뭘 알았는지는 바뀌지 않습니다.

이 차이를 받아들이면 갱신 규칙이 단순해집니다. 기록 시간 쪽의 갱신은 언제나 “지금 닫고 지금 연다”뿐입니다. 기록 시간을 과거로 소급해서 고치는 건 기록의 무결성을 깨는 일이고, 요구사항에 사기가 포함된 게 아니라면 할 이유가 없습니다. 소급해야 할 일은 전부 실제 시간 축에서 처리하면 됩니다.

API에도 그대로 반영됩니다. 쓰기 API는 기록 시간을 인자로 받지 않습니다. 기록 시간은 시스템이 찍습니다. 읽기 API는 기록 시간을 받되 기본값을 “지금”으로 둡니다.

class Employee {
    private final BitemporalHistory<Money> salary = new BitemporalHistory<>();

    // 쓰기: 실제 날짜만 받는다. 기록 시간은 시스템이 찍는다
    public void changeSalary(LocalDate effectiveFrom, Money value) {
        salary.put(effectiveFrom, value, Clock.now());
    }

    // 읽기: 대부분의 코드는 이 두 개만 쓴다
    public Money salary()                 { return salaryAt(Clock.today()); }
    public Money salaryAt(LocalDate on)   { return salaryAt(on, Clock.now()); }

    // 감사·정산 같은 소수의 코드만 이걸 쓴다
    public Money salaryAt(LocalDate on, Instant knownAt) {
        return salary.get(on, knownAt);
    }
}

이렇게 하면 두 번째 축은 쓰는 쪽에서는 완전히 안 보이고, 읽는 쪽에서도 필요한 코드만 신경 쓰면 됩니다. bi-temporal의 복잡함을 시스템 전체로 퍼뜨리지 않는 가장 확실한 방법입니다.

갱신 인터페이스도 좁게 시작하는 걸 권합니다. 시작일·종료일·값을 아무렇게나 바꿀 수 있는 범용 갱신은 쓰는 쪽이 시간 데이터의 동작을 너무 많이 알아야 합니다. 대부분의 실무 변경은 “X일부로 Y로 바꾼다”는 추가 변경입니다. 이것 하나만 제공하고, 기간 자체를 고쳐야 하는 드문 경우(이사 날짜를 잘못 입력했다든가)만 별도의 저수준 인터페이스로 뺍니다. 가장 작은 인터페이스가 아니라 가장 쓰기 쉬운 인터페이스가 목표입니다.

Clock을 따로 둔 이유도 있습니다. 시스템 시계를 직접 부르면 테스트가 불가능하고, 운영 중에 “지난 금요일 기준으로 배치를 다시 돌리는” 일도 못 합니다. 현재 시각은 반드시 한 단계를 거쳐서 얻게 하세요. 이 간접 계층이 있으면 bi-temporal 테스트를 “시계를 옮기고, 값을 넣고, 다시 시계를 옮기는” 리듬으로 자연스럽게 쓸 수 있습니다.

Clock.set(at("2026-01-01")); a.changeSalary(date("2026-01-01"), won(3_000_000));
Clock.set(at("2026-03-15")); a.changeSalary(date("2026-02-15"), won(3_200_000));
Clock.set(at("2026-04-05")); a.changeSalary(date("2026-02-15"), won(3_150_000));

var feb25 = date("2026-02-25");
assertEquals(won(3_000_000), a.salaryAt(feb25, at("2026-02-25")));
assertEquals(won(3_200_000), a.salaryAt(feb25, at("2026-03-20")));
assertEquals(won(3_150_000), a.salaryAt(feb25));

5. 저장: 상태 테이블이냐, 이벤트냐

접근 API는 단순하게 만들 수 있지만 저장은 그렇지 않습니다. 시간 데이터를 기본 지원하는 DB도 있지만(SQL:2011의 system-versioned table 등), 오래 남을 데이터를 특정 벤더 기능에 묶는 게 부담스러워서 직접 스키마를 짜는 경우가 많습니다. 선택지는 크게 두 가지입니다.

방법 1: bi-temporal 상태 테이블

각 축마다 시작/끝 컬럼을 둡니다.

CREATE TABLE employee_salary (
    employee_id    VARCHAR(20)   NOT NULL,
    salary         DECIMAL(12,0) NOT NULL,
    valid_from     DATE          NOT NULL,  -- 실제 시간 [from, to)
    valid_to       DATE          NOT NULL,
    recorded_from  TIMESTAMP     NOT NULL,  -- 기록 시간 [from, to)
    recorded_to    TIMESTAMP     NOT NULL
);

예시는 이렇게 쌓입니다.

행월급valid_fromvalid_torecorded_fromrecorded_to
a300만1/1∞1/13/15
b300만1/12/153/15∞
c320만2/15∞3/154/5
d315만2/15∞4/5∞
-- :known_at 시점에 알던 바로, :on 날짜의 월급은?
SELECT salary
FROM   employee_salary
WHERE  employee_id = :id
  AND  :on       >= valid_from    AND :on       < valid_to
  AND  :known_at >= recorded_from AND :known_at < recorded_to;

조회는 깔끔하지만 갱신이 번거롭습니다. 3월 15일 정정 한 번에 기존 행 a의 recorded_to를 닫고, 실제 기간을 둘로 쪼갠 b와 c를 넣어야 합니다. 이 로직을 애플리케이션 곳곳에 흩어 두면 반드시 어딘가에서 기간이 겹치거나 빈틈이 생깁니다. 저장 프로시저든 라이브러리든 한 곳으로 모으고, 기간 겹침을 검증하는 제약(PostgreSQL이면 EXCLUDE USING gist)을 같이 거는 걸 권합니다.

방법 2: 이벤트로 저장하고 상태는 계산

상태 대신 변경 자체를 이벤트로 남깁니다. 같은 이력이 네 행에서 세 행으로 줄어듭니다.

recorded_ateffective_from이벤트값
1/11/1SalaryChanged300만
3/152/15SalaryChanged320만
4/52/15SalaryChanged315만

정정이 와도 이벤트 하나를 추가할 뿐이니, 기록 이력이 append-only라는 성질과 딱 맞습니다. 여기서 놓치면 안 되는 조건이 하나 있습니다. 이벤트가 bi-temporal을 지원하려면 이벤트 자체가 bi-temporal이어야 합니다. 모든 이벤트에 “언제 기록됐나”와 “언제부터 효력이 있나”가 둘 다 있어야 합니다. 이벤트 소싱을 한다고 해서 자동으로 bi-temporal이 되는 게 아닙니다. 이벤트에 발생 시각 하나만 있으면 결국 한 축짜리입니다.

조회는 이벤트를 걸러서 다시 계산하는 일이 됩니다.

record SalaryChanged(Instant recordedAt, LocalDate effectiveFrom, Money value) {}

Money salaryAt(List<SalaryChanged> events, LocalDate on, Instant knownAt) {
    return events.stream()
            .filter(e -> !e.recordedAt().isAfter(knownAt))  // 그때 알던 것만
            .filter(e -> !e.effectiveFrom().isAfter(on))    // 그날 이전에 효력이 생긴 것만
            .max(Comparator.comparing(SalaryChanged::effectiveFrom)
                    .thenComparing(SalaryChanged::recordedAt)) // 같은 효력일이면 나중에 안 것이 이김
            .map(SalaryChanged::value)
            .orElseThrow();
}

매번 재계산하는 건 비싸니 스냅숏이나 프로젝션으로 캐시합니다. 그리고 이 구조의 진짜 장점은 같은 이벤트에서 소비자마다 다른 모양의 읽기 모델을 만들 수 있다는 점입니다.

flowchart LR
    E[("bi-temporal 이벤트 원장<br/>append-only")]
    E --> P1["현재 상태 테이블<br/>(대부분의 서비스)"]
    E --> P2["실제 이력 테이블<br/>(조회 화면, 분석)"]
    E --> P3["bi-temporal 테이블<br/>(감사, 정산)"]

대부분의 소비자에게는 현재 값이나 실제 이력만 담은 단순한 테이블을 주고, 감사·정산처럼 두 축이 필요한 소수에게만 bi-temporal 프로젝션을 줍니다. 두 축의 복잡함을 필요한 곳에만 노출하는 구조라서, 개인적으로는 정정이 잦은 도메인이라면 이쪽을 먼저 검토합니다.

6. 분석 계층에서: SCD Type 2가 놓치는 것

데이터 웨어하우스를 다뤄 봤다면 이 문제를 SCD(Slowly Changing Dimension) Type 2라는 이름으로 이미 만나 봤을 겁니다. 값이 바뀌면 기존 행을 덮어쓰지 않고 새 행을 추가하고, 행마다 대리 키와 유효 기간을 둡니다.

CREATE TABLE dim_employee (
    employee_sk     BIGINT PRIMARY KEY,   -- 버전의 식별자
    employee_id     VARCHAR(20) NOT NULL, -- 연속성
    salary          DECIMAL(12,0) NOT NULL,
    effective_from  DATE NOT NULL,
    effective_to    DATE NOT NULL,        -- 다음 행의 effective_from과 같음
    is_current      BOOLEAN NOT NULL
);

앞에서 본 Temporal Object를 테이블로 옮긴 모양 그대로입니다. 자연 키가 연속성이고, 대리 키가 버전이고, 유효 기간이 Effectivity입니다. 그런데 SCD Type 2를 bi-temporal 관점에서 보면 조심해야 할 지점이 세 군데 있습니다.

effective_from이 어느 축인지 흐려진다. 소스의 업무 날짜(2월 15일)를 넣으면 실제 시간이고, ETL이 변경을 감지한 날(3월 15일)을 넣으면 기록 시간입니다. 소스에 업무 날짜가 없어서 적재 시각을 넣고는, 그걸 실제 시간처럼 읽는 경우가 정말 흔합니다. 컬럼 이름부터 valid_from인지 loaded_at인지 구분해 두세요.

팩트의 외래 키가 기록 시간을 붙잡고 있다. 팩트는 적재 시점에 유효한 대리 키를 저장합니다. 2월 25일 급여 팩트는 300만 원 행을 가리키고, 나중에 소급 인상이 들어와도 그대로입니다. 결과적으로 팩트 행이 “적재 당시 알던 버전”을 고정합니다. 2장에서 말한 “행동이 자기 입력을 기록한다”와 같은 효과죠. 그런데 이걸 모르고 팩트 날짜로 차원을 다시 조인하면 다른 숫자가 나옵니다.

-- A) 팩트가 붙잡은 버전: 지급 당시 알던 값 (300만)
SELECT f.pay_date, d.salary
FROM   fact_payroll f
JOIN   dim_employee d ON d.employee_sk = f.employee_sk;

-- B) 팩트 날짜로 다시 찾은 버전: 지금 아는 실제 값 (315만)
SELECT f.pay_date, d.salary
FROM   fact_payroll f
JOIN   dim_employee d
  ON   d.employee_id = f.employee_id
 AND   f.pay_date >= d.effective_from AND f.pay_date < d.effective_to;

둘 다 맞는 쿼리입니다. 다른 질문에 답할 뿐입니다. A는 “2월 25일에 알던 2월 25일 값”, B는 “지금 아는 2월 25일 값”입니다. 리포트마다 어느 쪽인지 명시하지 않으면, 소급 정정이 있을 때마다 “숫자가 안 맞는다”는 문의가 들어옵니다.

소급 정정이 이력을 지운다. 늦게 도착한 변경을 처리하는 표준 방법은 차원에 행을 끼워 넣고 영향받은 팩트를 다시 서술(restate)하는 것입니다. 그러면 정합성은 맞지만 “정정 전에 리포트가 뭘 보여줬나”는 사라집니다. 4월 5일 정정(320 → 315)에서는 더 분명합니다. 기간이 겹치면 안 되니 320만 원 행의 값을 덮어써야 하고, 3월 25일 정산이 왜 320만 원 기준이었는지 설명할 근거가 같이 지워집니다. SCD Type 2는 기본적으로 실제 시간 한 축짜리 모델이라는 걸 인정하고 쓰는 게 좋습니다.

두 축이 다 필요하다면 방법은 둘입니다. 차원에 recorded_from/recorded_to를 추가해서 5장의 bi-temporal 테이블로 만들거나, 기록 시간 축을 저장소에 맡기는 겁니다. Delta Lake나 Iceberg의 time travel(TIMESTAMP AS OF)은 “그 시점에 테이블이 어땠나”를 보여주니 사실상 기록 시간 축입니다. SCD Type 2로 실제 시간을 모델에 넣고, 기록 시간은 time travel에 맡기는 분업이죠. 다만 time travel은 오래된 스냅숏이 정리(vacuum, expire snapshots)되면 돌아갈 수 없습니다. 감사 목적이라면 보존 정책부터 확인하세요. 보존 기간이 감사 요구 기간보다 짧다면 이 분업은 성립하지 않습니다.

7. 시점 자체를 정하는 규칙

어떤 모델을 고르든 모든 패턴이 시점을 인덱스로 씁니다. 여기서 틀리면 전부 흔들리니 팀 규칙으로 못 박아 두는 게 좋습니다.

  • 구간은 반열린 [from, to)로 통일한다. “끝 = 다음 행의 시작”이 되어 겹침과 빈틈을 검증하기 쉽습니다. 닫힌 구간과 섞이면 경계일에 두 행이 잡히거나 하루가 빕니다. 반열린 구간을 쓰면서 BETWEEN으로 조회하는 실수도 흔합니다.
  • 열린 끝은 9999-12-31 하나로. NULL을 쓰면 모든 조회에 OR valid_to IS NULL이 붙습니다.
  • 축마다 정밀도를 따로 정한다. 실제 시간은 업무 단위(대개 일)에 맞추고, 업무가 일 단위인데 타임스탬프를 쓰면 몇 밀리초 차이로 “같은 날”이 같지 않게 됩니다. 반대로 기록 시간은 세밀할수록 좋습니다. 오후 2시에 고치고, 3시에 정산을 돌리고, 4시에 다시 고쳤다면 날짜 단위로는 3시에 쓰인 값을 재현할 수 없습니다.
  • 시간대는 필요할 때만. 일 단위 업무 날짜에 시간대를 붙이면 다른 지역에서 볼 때 날짜가 밀립니다. 기록 시간은 UTC 타임스탬프, 실제 시간은 시간대 없는 업무 날짜로 두는 조합이 대부분의 경우에 무난합니다.
  • 현재 시각은 간접 계층으로 얻는다. 4장의 Clock입니다. 로그에는 처리 기준 시각과 실제 시스템 시각을 둘 다 남겨야 할 수도 있습니다.

8. 기록 시간을 넘어서: 관점

조금 더 나가 보면, 기록 시간은 “누가 알았나”에 따라서도 달라질 수 있습니다. 인사팀은 2월 15일부터 315만 원이라는 걸 알았는데, 급여팀은 3월 15일에 320만 원이라는 잘못된 값을 받았다가 4월 5일에야 고쳤다고 해 봅시다.

부서기록 기간실제 기간월급
인사팀2/15 ~2/15 ~315만
급여팀3/15 ~ 4/42/15 ~320만
급여팀4/5 ~2/15 ~315만

“부서 + 기록 시점”을 묶어 하나의 관점(perspective)으로 보면, “2월 25일의 인사팀 관점에서 A의 월급은 315만 원이었다”처럼 말할 수 있습니다. 여러 시스템이 같은 데이터를 서로 다른 시점에 받아 가는 MSA 환경이라면, “어느 서비스가 언제 무엇을 알았나”를 추적해야 하는 순간이 꽤 옵니다. 이벤트 원장에 소비 시점을 같이 남겨 두면 이 질문에 답할 수 있습니다.

관점은 기록 시간이 아닌 것도 담을 수 있습니다. “전 직원 10% 인상을 했다면?” 같은 가정 시나리오나 여러 예산안을 각각 관점으로 두고, 같은 실제 시간 축 위에 겹쳐 비교하는 식입니다. 쓸 일이 bi-temporal보다는 적지만, 이런 요구가 보이면 축을 하나 더 늘리기보다 “관점 키”를 두는 쪽이 모델을 덜 망가뜨립니다.

9. 이력이 해결하지 않는 것

마지막으로 착각하기 쉬운 부분이 하나 있습니다. bi-temporal 이력을 완벽하게 만들어도 소급 변경의 후속 효과는 해결되지 않습니다. 300만 원을 지급했는데 실제로는 315만 원이었다면 차액을 지급해야 하고, 그 차액 때문에 세금 구간이 바뀔 수도 있습니다. 이력은 “무엇이 사실이었고 우리가 뭘 알았는지”를 알려줄 뿐, “그래서 무엇을 해야 하는지”는 정하지 않습니다.

그래서 정정은 이력 갱신으로 끝나면 안 되고, 정정 이벤트를 받아 보상 처리를 하는 별도의 흐름이 있어야 합니다. “원래 그랬어야 할 세계”를 따로 계산해서 현재와 비교하는 방식(Fowler는 이를 Parallel Model이라고 부릅니다)이 한 가지 방법입니다. 이벤트 원장이 있으면 정정 시점 기준으로 이벤트를 재생해 “정정 전 계산”과 “정정 후 계산”을 둘 다 만들 수 있으니, 이 차이를 정산 대상으로 넘기면 됩니다.

정리: 설계 체크리스트

이런 데이터를 만나면 저는 대략 이 순서로 판단합니다.

  1. 질문을 분류한다. “그때 알던 값”을 묻는 사람이 실제로 있는가?
  2. 피할 수 있으면 피한다. 소급 금지 정책, 계산 결과에 입력값 기록, 정정 마감 앞당기기 중 하나로 끝나지 않는가?
  3. 어느 축을 모델에, 어느 축을 로그에 둘지 명시한다. 그리고 로그에는 항상 두 날짜를 남긴다.
  4. 시간을 붙일 단위를 고른다. 로그 → Effectivity → Temporal Property → Temporal Object, 필요하면 Snapshot.
  5. 두 축의 갱신 규칙을 분리한다. 실제 시간은 고칠 수 있고, 기록 시간은 시스템이 찍는 append-only. 쓰기 API는 기록 시간을 받지 않는다.
  6. 저장 방식을 고른다. 정정이 드물면 bi-temporal 테이블, 잦으면 bi-temporal 이벤트 원장 + 소비자별 프로젝션.
  7. 분석 계층에서 축을 다시 확인한다. effective_from은 어느 축인가, 팩트의 외래 키는 어느 축을 붙잡고 있나, time travel 보존 기간은 충분한가.
  8. 시점 규칙을 못 박는다. 반열린 구간, 열린 끝 표기, 축별 정밀도, 시간대, Clock.
  9. 정정의 후속 효과는 별도 흐름으로 처리한다.

두 축을 처음 이해했을 때 제일 크게 느낀 건, 소급 정정이 늘 골치 아팠던 이유가 데이터가 복잡해서가 아니라 성질이 다른 두 시간을 한 칸에 넣어 왔기 때문이라는 점이었습니다. 그리고 두 축을 분명히 알고 나면, 역설적으로 어디까지는 만들지 않아도 되는지도 같이 보입니다. 대부분의 시스템은 축 하나와 두 날짜를 남기는 로그로 충분합니다. 두 축을 꺼내는 건 그걸로 안 될 때입니다.

참고

Previous posts

View all posts →

Comments