백업 / 복구(WAL)

SHOW wal_level;                              -- WAL에 기록하는 정보의 양 (기본 replica)
SHOW synchronous_commit;                    -- on: 커밋 때 WAL을 디스크에 기록하고 응답
SELECT pg_current_wal_lsn();               -- 현재 WAL 쓰기 위치
CHECKPOINT;                                 -- 체크포인트를 바로 실행 (보통은 자동)

-- postgresql.conf: WAL 아카이브 켜기
-- archive_mode = on
-- archive_command = 'test ! -f /archive/%f && cp %p /archive/%f'

-- 셸: 베이스 백업
-- pg_basebackup -D /backup/base -Ft -z -P

-- 복구할 때 (postgresql.conf)
-- restore_command = 'cp /archive/%f %p'
-- recovery_target_time = '2026-10-06 14:30:00'
-- 데이터 디렉터리에 recovery.signal 파일을 만들고 서버를 시작

class Db:
    def __init__(self):
        self.disk = {'x': 1, 'y': 5}          # 데이터 파일
        self.wal = []                         # 디스크의 WAL
        self.mem = dict(self.disk)            # 메모리 버퍼
        self.ckpt = 0                         # 마지막 체크포인트 이후 WAL 시작 위치

    def write(self, tx, key, value):
        self.wal.append((tx, 'SET', key, self.mem[key], value))   # 로그를 먼저 기록
        self.mem[key] = value                                     # 그 다음 메모리 페이지 변경

    def commit(self, tx):
        self.wal.append((tx, 'COMMIT'))       # 커밋 기록이 디스크에 닿으면 커밋 완료

    def checkpoint(self):
        self.disk = dict(self.mem)            # 더티 페이지를 데이터 파일에 기록
        self.ckpt = len(self.wal)

    def crash_and_recover(self):
        self.mem = dict(self.disk)            # 메모리는 사라지고 데이터 파일만 남음
        committed = {r[0] for r in self.wal[self.ckpt:] if r[1] == 'COMMIT'}
        for r in self.wal[self.ckpt:]:        # 체크포인트 이후 WAL 재생(redo)
            if r[1] == 'SET' and r[0] in committed:
                self.mem[r[2]] = r[4]
        return self.mem

db = Db()
db.write('T1', 'x', 2)
db.commit('T1')                               # T1 커밋 (데이터 파일에는 아직 x = 1)
db.write('T2', 'y', 9)                        # T2는 커밋하지 못한 채 장애
print('장애 직전:', db.mem, '데이터 파일:', db.disk)
print('복구 결과:', db.crash_and_recover())
print('WAL:', db.wal)
# 장애 직전: {'x': 2, 'y': 9} 데이터 파일: {'x': 1, 'y': 5}
# 복구 결과: {'x': 2, 'y': 5}
# WAL: [('T1', 'SET', 'x', 1, 2), ('T1', 'COMMIT'), ('T2', 'SET', 'y', 5, 9)]

record Wal(int t, String op, String key, Integer val) {}

static Map<String, Integer> restore(Map<String, Integer> base, List<Wal> archive, int target) {
    Map<String, Integer> db = new TreeMap<>(base);          // 베이스 백업을 복원
    for (Wal w : archive) {
        if (w.t() > target) break;                          // 복구 목표 시점에서 멈춤
        if (w.op().equals("SET")) db.put(w.key(), w.val());
        else db.remove(w.key());
    }
    return db;
}

Map<String, Integer> base = Map.of("x", 1, "y", 5);       // t = 0의 베이스 백업
List<Wal> archive = List.of(
    new Wal(1, "SET", "x", 2), new Wal(3, "SET", "y", 9),
    new Wal(4, "SET", "x", 3), new Wal(5, "DELETE", "x", null));
System.out.println("t=4까지: " + restore(base, archive, 4));   // t=4까지: {x=3, y=9}
System.out.println("끝까지: " + restore(base, archive, 8));      // 끝까지: {y=9}