BASE

// BASE 모델 - Node.js + Cassandra 예제
const cassandra = require('cassandra-driver');

class EventuallyConsistentUserService {
    constructor() {
        // Cassandra는 분산 설계로 BASE 모델 기본 지원
        this.client = new cassandra.Client({
            contactPoints: ['node1', 'node2', 'node3'],
            localDataCenter: 'datacenter1',
            keyspace: 'users_ks'
        });
    }

    /**
     * 사용자 프로필 업데이트
     * Cassandra는 "Last Write Wins" 전략 사용
     */
    async updateProfile(userId, profileData) {
        const query = `
            UPDATE users
            SET name = ?, bio = ?, updated_at = toTimestamp(now())
            WHERE user_id = ?
        `;

        // 일관성 수준 선택
        await this.client.execute(query,
            [profileData.name, profileData.bio, userId],
            {
                // ONE: 한 노드 확인 후 반환 (빠름, 낮은 일관성)
                // QUORUM: 과반수 노드 확인 (균형)
                // ALL: 모든 노드 확인 (느림, 높은 일관성)
                consistency: cassandra.types.consistencies.one
            }
        );

        console.log('✅ 프로필 업데이트됨 (최종 일관성으로 전파 중)');
    }

    /**
     * 프로필 조회 - 일관성 수준 선택 가능
     */
    async getProfile(userId, strongConsistency = false) {
        const query = 'SELECT * FROM users WHERE user_id = ?';

        const result = await this.client.execute(query, [userId], {
            consistency: strongConsistency
                ? cassandra.types.consistencies.quorum
                : cassandra.types.consistencies.one
        });

        return result.rows[0];
    }

    /**
     * 팔로워 수 카운터 - 분산 카운터 사용
     * Cassandra Counter는 최종 일관성으로 동작
     */
    async incrementFollowers(userId) {
        const query = `
            UPDATE user_stats
            SET follower_count = follower_count + 1
            WHERE user_id = ?
        `;

        await this.client.execute(query, [userId], {
            consistency: cassandra.types.consistencies.one
        });
    }
}

// 읽기 복구 (Read Repair) 시뮬레이션
class ReadRepairExample {
    /**
     * Cassandra의 Read Repair 동작 원리
     * 읽기 시 불일치 발견하면 자동으로 복구
     */
    async readWithRepair(client, userId) {
        // QUORUM 읽기: 여러 복제본 비교
        const query = 'SELECT * FROM users WHERE user_id = ?';

        const result = await client.execute(query, [userId], {
            consistency: cassandra.types.consistencies.quorum
        });

        // 내부적으로:
        // 1. 여러 노드에서 데이터 읽기
        // 2. 타임스탬프 비교
        // 3. 오래된 데이터 가진 노드에 최신 데이터 전파
        // => "최종 일관성"이 실현되는 메커니즘

        return result.rows[0];
    }
}

// 사용 예시
async function main() {
    const userService = new EventuallyConsistentUserService();

    // 프로필 업데이트 (빠른 쓰기)
    await userService.updateProfile('user123', {
        name: '홍길동',
        bio: '소프트웨어 개발자'
    });

    // 일반 조회 (최종 일관성, 빠름)
    const profile = await userService.getProfile('user123', false);
    console.log('프로필:', profile);

    // 중요한 조회 (강한 일관성, 느림)
    const accurateProfile = await userService.getProfile('user123', true);
    console.log('정확한 프로필:', accurateProfile);
}

┌─────────────────────────────────────────────────────────────────────┐
│                     ACID vs BASE 비교                                │
├─────────────────────────────────────────────────────────────────────┤

    ACID (관계형 DB)                    BASE (NoSQL/분산 시스템)
    ═══════════════                    ═══════════════════════

    ┌─────────────┐                    ┌─────────────┐
    │  Atomicity  │                    │  Basically  │
    │   원자성    │                    │  Available  │
    │ 전부/전무   │                    │  기본가용성  │
    └─────────────┘                    └─────────────┘
          ↓                                  ↓
    트랜잭션 전체 성공                   장애 시에도 응답 반환
    또는 전체 롤백                      (오래된 데이터일 수 있음)

    ┌─────────────┐                    ┌─────────────┐
    │ Consistency │                    │ Soft State  │
    │   일관성    │                    │  유연한상태  │
    │ 즉각적 반영 │                    │ 중간상태허용 │
    └─────────────┘                    └─────────────┘
          ↓                                  ↓
    쓰기 후 읽기는                      복제 중 일시적
    항상 최신 데이터                    불일치 허용

    ┌─────────────┐                    ┌─────────────┐
    │  Isolation  │                    │ Eventually  │
    │   격리성    │                    │ Consistent  │
    │ 동시성제어  │                    │ 최종일관성  │
    └─────────────┘                    └─────────────┘
          ↓                                  ↓
    트랜잭션 간                         시간이 지나면
    간섭 없음                          모든 노드 동기화

    ┌─────────────┐
    │ Durability  │
    │   지속성    │
    │ 영구 저장   │
    └─────────────┘


    ═══════════════════════════════════════════════════════════════

    적합한 사용 사례
    ───────────────

    ACID 선택                          BASE 선택
    ──────────                         ──────────
    • 금융 거래                        • 소셜 미디어 피드
    • 결제 시스템                      • 좋아요/조회수 카운터
    • 재고 관리 (정확성 중요)          • 쇼핑 카트 (결제 전)
    • 예약 시스템                      • 로그/분석 데이터
    • 사용자 인증                      • 추천 시스템


    ═══════════════════════════════════════════════════════════════

    최종 일관성의 시간 흐름
    ─────────────────────

    T=0ms (쓰기)          T=50ms              T=200ms (최종 일관성 달성)
    ┌─────────┐          ┌─────────┐          ┌─────────┐
    │ Node A  │          │ Node A  │          │ Node A  │
    │ v=100 ✓ │  ──→     │ v=100   │  ──→     │ v=100   │
    └─────────┘          └─────────┘          └─────────┘
    ┌─────────┐          ┌─────────┐          ┌─────────┐
    │ Node B  │          │ Node B  │          │ Node B  │
    │ v=99    │  ──→     │ v=100 ✓ │  ──→     │ v=100   │
    └─────────┘          └─────────┘          └─────────┘
    ┌─────────┐          ┌─────────┐          ┌─────────┐
    │ Node C  │          │ Node C  │          │ Node C  │
    │ v=99    │  ──→     │ v=99    │  ──→     │ v=100 ✓ │
    └─────────┘          └─────────┘          └─────────┘

    불일치 상태             복제 진행 중          모든 노드 동기화!
    (Soft State)          (Soft State)        (Eventually Consistent)

└─────────────────────────────────────────────────────────────────────┘