ISO 8601과 레거시 타임존의 딜레마: 초 단위 오프셋이 만드는 개발자의 악몽

// 문제가 되는 케이스
const historicalDate = "1900-01-01T12:00:00+08:27:52";

// JavaScript Date 객체로 파싱 시도
const date = new Date(historicalDate);
console.log(date); // Invalid Date

// Go의 time 패키지 예시
layout := "2006-01-02T15:04:05-07:00"
timeStr := "1900-01-01T12:00:00+08:27:52"

// 파싱 실패
_, err := time.Parse(layout, timeStr)
if err != nil {
    // parsing time "1900-01-01T12:00:00+08:27:52": extra text: :52
    log.Fatal(err)
}

-- PostgreSQL에서 TIMESTAMPTZ 타입으로 저장 시도
INSERT INTO events (created_at) 
VALUES ('1900-01-01T12:00:00+08:27:52');
-- ERROR: invalid input syntax for type timestamp with time zone

import pytz
from datetime import datetime

seoul_tz = pytz.timezone('Asia/Seoul')

# 섬머타임이 적용된 복잡한 시기들
test_dates = [
    datetime(1900, 6, 1, 12, 0),   # 조선시대: LMT
    datetime(1910, 6, 1, 12, 0),   # 대한제국: KST
    datetime(1949, 7, 1, 12, 0),   # 섬머타임 적용: KDT  
    datetime(1949, 12, 1, 12, 0),  # 섬머타임 해제: KST
    datetime(1987, 8, 1, 12, 0),   # 올림픽 준비 섬머타임: KDT
    datetime(2000, 6, 1, 12, 0),   # 현대: KST
]

print("연도별 Asia/Seoul 타임존 변화:")
for date in test_dates:
    try:
        localized = seoul_tz.localize(date)
        offset_hours = localized.utcoffset().total_seconds() / 3600
        print(f"{date.year}년 {date.month}월: UTC{offset_hours:+.2f} ({localized.tzname()})")
    except Exception as e:
        print(f"{date.year}년: 처리 불가 - {e}")

# 예상 출력:
# 1900년 6월: UTC+8.47 (LMT) - 8시간 27분 52초
# 1910년 6월: UTC+8.50 (KST) - 8시간 30분
# 1949년 7월: UTC+9.50 (KDT) - 섬머타임 적용, 9시간 30분
# 1949년 12월: UTC+8.50 (KST) - 섬머타임 해제, 8시간 30분  
# 1987년 8월: UTC+10.00 (KDT) - 올림픽 대비 섬머타임
# 2000년 6월: UTC+9.00 (KST) - 현재 표준시

# 1987년 섬머타임 시작: 5월 10일 오전 2시가 3시로 점프
# 이 시간대는 "존재하지 않는 시간"
try:
    non_existent = seoul_tz.localize(datetime(1987, 5, 10, 2, 30))
except pytz.NonExistentTimeError as e:
    print("존재하지 않는 시간:", e)

# 1987년 섬머타임 종료: 10월 11일 오전 3시가 2시로 되돌아감  
# 이 시간대는 "중복되는 시간"
try:
    ambiguous = seoul_tz.localize(datetime(1987, 10, 11, 2, 30))
except pytz.AmbiguousTimeError as e:
    print("애매한 시간:", e)

// Java에서도 동일하게 작동
ZoneId seoul = ZoneId.of("Asia/Seoul");
LocalDateTime historical = LocalDateTime.of(1900, 6, 1, 12, 0);
ZonedDateTime zoned = historical.atZone(seoul);

System.out.println(zoned.getOffset()); // +08:27:52 자동 계산

-- 데이터베이스에는 단순히 timestamp + timezone 이름만 저장
CREATE TABLE events (
    id SERIAL,
    event_timestamp BIGINT,
    timezone_name VARCHAR(50) DEFAULT 'Asia/Seoul'
);

-- 조회 시 라이브러리가 섬머타임까지 모두 고려해서 변환
-- 1987년 여름 데이터도 자동으로 +10:00 오프셋 적용

import java.time.*;
import java.time.format.DateTimeFormatter;

// 커스텀 오프셋 생성
ZoneOffset historicalOffset = ZoneOffset.ofHoursMinutesSeconds(8, 27, 52);
OffsetDateTime historicalTime = OffsetDateTime.of(
    1900, 1, 1, 12, 0, 0, 0, 
    historicalOffset
);

System.out.println(historicalTime);
// 1900-01-01T12:00+08:27:52

// ISO 8601 호환 형식으로 변환
ZonedDateTime utcTime = historicalTime.atZoneSameInstant(ZoneOffset.UTC);
System.out.println(utcTime.format(DateTimeFormatter.ISO_INSTANT));
// 1900-01-01T03:32:08Z

from datetime import datetime, timezone, timedelta

# 초 단위 오프셋 생성
historical_offset = timezone(timedelta(hours=8, minutes=27, seconds=52))
historical_time = datetime(1900, 1, 1, 12, 0, 0, tzinfo=historical_offset)

print(historical_time)
# 1900-01-01 12:00:00+08:27:52

# UTC로 변환하여 저장
utc_time = historical_time.astimezone(timezone.utc)
print(utc_time.isoformat())
# 1900-01-01T03:32:08+00:00

// Day.js with timezone plugin
const dayjs = require('dayjs');
const utc = require('dayjs/plugin/utc');
const timezone = require('dayjs/plugin/timezone');

dayjs.extend(utc);
dayjs.extend(timezone);

// 커스텀 오프셋 처리 함수
function parseHistoricalTimezone(dateStr) {
    const match = dateStr.match(/(.+)([+-])(\d{2}):(\d{2}):(\d{2})$/);
    if (!match) return null;
    
    const [, datepart, sign, hours, minutes, seconds] = match;
    const offsetMinutes = (parseInt(hours) * 60 + parseInt(minutes)) * (sign === '+' ? 1 : -1);
    const offsetSeconds = parseInt(seconds) * (sign === '+' ? 1 : -1);
    
    // 초는 분으로 근사치 변환 (데이터 손실 발생)
    const totalOffsetMinutes = offsetMinutes + Math.round(offsetSeconds / 60);
    
    return dayjs(datepart).utcOffset(totalOffsetMinutes);
}

const historicalDate = parseHistoricalTimezone("1900-01-01T12:00:00+08:27:52");
console.log(historicalDate.toISOString()); // 표준 ISO 8601 형식으로 출력

import java.time.*;
import java.time.zone.*;

// ZoneRules를 통한 역사적 타임존 조회
ZoneId seoulZone = ZoneId.of("Asia/Seoul");
ZoneRules rules = seoulZone.getRules();

// 특정 시점의 오프셋 조회
LocalDateTime historicalTime = LocalDateTime.of(1900, 1, 1, 12, 0);
ZoneOffset offset = rules.getOffset(historicalTime);

System.out.println("1900년 서울 오프셋: " + offset);
// 출력: +08:27:52 (IANA 데이터베이스 기준)

import pytz
from datetime import datetime
import zoneinfo

# pytz를 사용한 역사적 타임존
seoul_tz = pytz.timezone('Asia/Seoul')
historical_dt = datetime(1900, 1, 1, 12, 0)

# 해당 시점의 정확한 오프셋 계산
localized_dt = seoul_tz.localize(historical_dt)
print(f"UTC 오프셋: {localized_dt.strftime('%z')}")
print(f"UTC 시간: {localized_dt.utctimetuple()}")

const { DateTime } = require('luxon');

// IANA 타임존 데이터 활용
const historicalTime = DateTime.fromObject({
    year: 1900,
    month: 1,
    day: 1,
    hour: 12,
    minute: 0
}, { zone: 'Asia/Seoul' });

console.log('로컬 시간:', historicalTime.toString());
console.log('UTC 시간:', historicalTime.toUTC().toString());
console.log('오프셋:', historicalTime.offset / 60, '분');

-- 권장: Unix timestamp + 메타데이터 분리
CREATE TABLE historical_events (
    id SERIAL PRIMARY KEY,
    event_timestamp BIGINT NOT NULL,           -- Unix timestamp (UTC 기준)
    timezone_offset_seconds INTEGER,           -- 초 단위 오프셋 (30672 = +08:27:52)
    timezone_name VARCHAR(50),                 -- 'Asia/Seoul', 'Europe/London' 등
    timezone_precision VARCHAR(10) DEFAULT 'minute',
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- 인덱스 최적화
CREATE INDEX idx_events_timestamp ON historical_events(event_timestamp);
CREATE INDEX idx_events_timezone ON historical_events(timezone_offset_seconds);

-- 효율적인 시간 범위 쿼리
SELECT * FROM historical_events 
WHERE event_timestamp BETWEEN 1577836800 AND 1609459200;  -- 2020-2021년

-- 타임존별 그룹핑
SELECT timezone_offset_seconds, COUNT(*) 
FROM historical_events 
GROUP BY timezone_offset_seconds;

{
  "event": {
    "timestamp": 1577836800,
    "timezone_offset_seconds": 30672,
    "timezone_name": "Asia/Seoul_Historical",
    "metadata": {
      "original_format": "+08:27:52",
      "precision": "second"
    }
  }
}

// API 응답 처리
function parseEventTime(apiResponse) {
    const { timestamp, timezone_offset_seconds } = apiResponse.event;
    
    // UTC 시간 생성
    const utcDate = new Date(timestamp * 1000);
    
    // 로컬 시간 계산 (초 단위 오프셋 적용)
    const localTimestamp = timestamp + timezone_offset_seconds;
    const localDate = new Date(localTimestamp * 1000);
    
    return {
        utc: utcDate,
        local: localDate,
        offsetSeconds: timezone_offset_seconds
    };
}

public class HistoricalEvent {
    private final long timestamp;           // Unix timestamp
    private final String timezoneName;      // "Asia/Seoul"
    
    public HistoricalEvent(long timestamp, String timezoneName) {
        this.timestamp = timestamp;
        this.timezoneName = timezoneName;
    }
    
    public Instant getInstant() {
        return Instant.ofEpochSecond(timestamp);
    }
    
    public ZonedDateTime getLocalDateTime() {
        ZoneId zone = ZoneId.of(timezoneName);
        return ZonedDateTime.ofInstant(getInstant(), zone);
    }
    
    // JSON 직렬화용
    public Map<String, Object> toApiResponse() {
        return Map.of(
            "timestamp", timestamp,
            "timezone", timezoneName
        );
    }
}

from dataclasses import dataclass
from datetime import datetime
import zoneinfo

@dataclass
class HistoricalEvent:
    timestamp: int  # Unix timestamp
    timezone_name: str  # "Asia/Seoul"
    
    def to_utc_datetime(self) -> datetime:
        return datetime.fromtimestamp(self.timestamp, tz=zoneinfo.ZoneInfo('UTC'))
    
    def to_local_datetime(self) -> datetime:
        tz = zoneinfo.ZoneInfo(self.timezone_name)
        return datetime.fromtimestamp(self.timestamp, tz=tz)
    
    def get_offset_at_time(self) -> str:
        """해당 시점의 실제 오프셋 반환 (섬머타임 고려)"""
        local_dt = self.to_local_datetime()
        return local_dt.strftime('%z')