데이터베이스 관계도

mindmap
  root((데이터베이스<br/>197개 토픽))
    데이터베이스 기초
      기본 개념
        데이터베이스
        DBMS
        스키마
        데이터 독립성
        데이터 모델
        관계형 모델
        객체관계형 모델
    데이터 모델링
      개념적 모델링
        개념적 데이터 모델링
        ERD
        엔터티
        속성
        관계
        식별자
      논리적 모델링
        논리적 데이터 모델링
        슈퍼/서브타입 변환 전략
      물리적 모델링
        물리적 데이터 모델링
    정규화
      정규화 기본
        정규화
        함수 종속성
        이상현상
      정규형
        제1정규형
        제2정규형
        제3정규형
        BCNF
        제4정규형
        제5정규형
      역정규화
        역정규화
        테이블 병합
        테이블 분할
        파생 컬럼 추가
        슈퍼/서브타입 통합 전략
    무결성
      무결성
      참조 무결성
    트랜잭션
      트랜잭션 기본
        트랜잭션
        ACID 속성
        원자성
        일관성
        고립성
        지속성
      격리 수준
        격리 수준
        Dirty Read
        Non-Repeatable Read
        Phantom Read
    동시성 제어
      동시성 제어 기본
        동시성 제어
        락킹
        2PL
        교착상태
        Lock Escalation
      MVCC
        MVCC
        MVCC 구현
        Snapshot Isolation
      락 유형
        갭 락
        넥스트 키 락
      동시성 전략
        낙관적 동시성 제어
        비관적 동시성 제어
      교착상태 해결
        Wait-Die / Wound-Wait
        Wait-for Graph
    병행제어
      병행제어 문제점
      Phantom Read 해결
    회복
      회복
      WAL
      체크포인트
      ARIES 알고리즘
      섀도 페이징
      Redo/Undo 로그
      Vacuum
    SQL 및 데이터베이스 객체
      SQL 기본
        관계 대수
        SQL 분류
        정적 SQL vs 동적 SQL
      데이터베이스 객체
        뷰
        저장 프로시저
        트리거
        커서
    인덱스
      인덱스 기본
        인덱스
        B-Tree 인덱스
        B+Tree 인덱스
      특수 인덱스
        Hash 인덱스
        확장성 해싱
        Bitmap 인덱스
        함수 기반 인덱스
        Full-Text 인덱스
        다차원 색인 구조
        적응형 인덱싱
      인덱스 구조
        클러스터드 인덱스
        논클러스터드 인덱스
        복합 인덱스
        커버링 인덱스
    쿼리 최적화
      최적화 기본
        쿼리 최적화
        옵티마이저
        실행계획
        테이블 스캔
        인덱스 스캔
        통계정보
        힌트
        비용 기반 최적화
        히스토그램
        적응형 쿼리
      조인
        조인
        조인 알고리즘
        Nested Loop Join
        Hash Join
        Sort Merge Join
        Semi Join / Anti Join
      서브쿼리
        서브쿼리 최적화
      뷰 최적화
        물화 뷰
        증분 유지보수
    파티셔닝
      파티셔닝 기본
        파티셔닝
        Range 파티셔닝
        List 파티셔닝
        Hash 파티셔닝
        Composite 파티셔닝
        파티션 프루닝
        파티셔닝 전략
      샤딩
        샤딩
        샤드 키 선정
    복제/클러스터링
      복제
        복제
        동기 복제
        비동기 복제
        Quorum Replication
      클러스터링
        클러스터링
        페일오버
    NoSQL
      NoSQL 기본
        NoSQL
        CAP 이론
        PACELC 이론
        BASE 특성
        최종 일관성
      NoSQL 유형
        Key-Value Store
        Document Store
        Column-Family Store
        그래프 데이터베이스
    데이터 웨어하우스
      DW 기본
        데이터 웨어하우스
        OLTP vs OLAP
        OLAP 큐브
      스키마
        스타 스키마
        스노우플레이크 스키마
        팩트 테이블
        디멘션 테이블
        SCD
      ETL
        ETL / ELT
    데이터 레이크
      데이터 레이크
      레이크하우스
    데이터 품질
      데이터 품질
      데이터 프로파일링
      데이터 클렌징
      MDM
      데이터 품질 관리
    데이터 거버넌스
      데이터 거버넌스
      메타데이터 관리
      데이터 카탈로그
      데이터 리니지
    데이터 아키텍처
      데이터 패브릭
      데이터 메시
    빅데이터
      빅데이터 기본
        빅데이터
        Hadoop 에코시스템
        Hive / HBase
        HDFS
        Spark
        Apache 빅데이터 프레임워크 심화
      스트림 처리
        스트림 처리
        CDC
    데이터 마이닝
      데이터 마이닝 방법론
      텍스트 마이닝
      토픽 모델링
    특수 데이터베이스
      벡터 데이터베이스
      시계열 데이터베이스
      인메모리 데이터베이스
      Graph Database
      Columnar Storage
      공간 데이터베이스
    캐싱
      캐싱 전략
      캐싱 패턴 상세
    분산 트랜잭션
      분산 트랜잭션
      2PC
      Saga 패턴
      Saga Choreography vs Orchestration
      분산 트랜잭션 심화
      분산DB 투명성
      Vector Clock / Lamport Timestamp
    데이터베이스 보안
      데이터베이스 보안
      데이터 암호화
      데이터 마스킹
      감사 로깅
    백업/복구
      데이터베이스 백업
      백업/복구 전략
      백업 전략 상세
      데이터 마이그레이션
      PITR
    클라우드 데이터베이스
      클라우드 데이터베이스
      서버리스 데이터베이스
    NewSQL
      NewSQL
      CockroachDB
      TiDB
      Vitess
    데이터 도구
      Debezium
      Presto/Trino
      DuckDB
    DB 연결/실행
      Database Connection Pool
      Read Replica
      Multi-tenancy Database

개념적 모델링 (ERD, 엔터티, 관계)
    ↓
논리적 모델링 (테이블, 컬럼, 관계, 슈퍼/서브타입 변환)
    ↓
물리적 모델링 (저장구조, 인덱스, 파티션)

비정규형 (중복, 이상현상)
    ↓
1NF (원자값)
    ↓
2NF (부분 함수 종속 제거)
    ↓
3NF (이행 함수 종속 제거)
    ↓
BCNF (결정자 후보키)
    ↓
4NF/5NF (다치 종속, 조인 종속)

성능 최적화
    ↓
역정규화 (의도적 중복)
    ├─ 테이블 병합/분할
    ├─ 파생 컬럼 추가
    └─ 슈퍼/서브타입 통합

RDBMS (ACID)
  ├─ Atomicity (원자성)
  ├─ Consistency (일관성)
  ├─ Isolation (고립성)
  └─ Durability (지속성)

NoSQL (BASE)
  ├─ Basically Available (기본적 가용성)
  ├─ Soft state (유연한 상태)
  └─ Eventually consistent (최종 일관성)

Read Uncommitted (가장 낮음)
  ↓ Dirty Read 발생
Read Committed
  ↓ Non-Repeatable Read 발생
Repeatable Read
  ↓ Phantom Read 발생
Serializable (가장 높음)
  ↓ 성능 저하

Snapshot Isolation
  └─ MVCC 기반, Serializable에 근접한 성능

비관적 동시성 제어
  └─ 락킹 (Locking)
      ├─ Shared Lock (읽기)
      ├─ Exclusive Lock (쓰기)
      ├─ 2PL (Two-Phase Locking)
      ├─ Lock Escalation (잠금 상승)
      ├─ 갭 락 / 넥스트 키 락
      └─ 교착상태 → Wait-Die / Wound-Wait / Wait-for Graph

낙관적 동시성 제어
  └─ MVCC (Multi-Version Concurrency Control)
      └─ Snapshot Isolation

갱신 분실 (Lost Update)
더티 읽기 (Dirty Read)
비반복 읽기 (Non-Repeatable Read)
팬텀 읽기 (Phantom Read)
  └─ 해결: 갭 락, 넥스트 키 락, Serializable

B-Tree 계열
  ├─ B-Tree 인덱스 (범위 검색)
  └─ B+Tree 인덱스 (리프 노드 연결)

특수 인덱스
  ├─ Hash 인덱스 (등가 검색)
  ├─ 확장성 해싱 (동적 해시)
  ├─ Bitmap 인덱스 (카디널리티 낮은 컬럼)
  ├─ Full-Text 인덱스 (전문 검색)
  ├─ 다차원 색인 구조 (R-Tree, KD-Tree)
  └─ 적응형 인덱싱 (워크로드 기반 자동 조정)

인덱스 조직
  ├─ 클러스터드 (테이블 정렬)
  └─ 논클러스터드 (별도 구조)

관계 대수 (이론적 기반)
    ↓
SQL 분류
  ├─ DDL (CREATE, ALTER, DROP)
  ├─ DML (SELECT, INSERT, UPDATE, DELETE)
  ├─ DCL (GRANT, REVOKE)
  └─ TCL (COMMIT, ROLLBACK)

데이터베이스 객체
  ├─ 뷰 (가상 테이블)
  ├─ 저장 프로시저 (서버측 로직)
  ├─ 트리거 (이벤트 기반 자동 실행)
  └─ 커서 (행 단위 처리)

실행 방식
  ├─ 정적 SQL (컴파일 타임)
  └─ 동적 SQL (런타임)

Nested Loop Join
  ├─ 작은 테이블 × 큰 테이블
  └─ 인덱스 있을 때 효율적

Hash Join
  ├─ 해시 테이블 생성
  └─ 대용량 등가 조인

Sort Merge Join
  ├─ 정렬 후 병합
  └─ 범위 조인, 정렬된 데이터

Semi Join / Anti Join
  ├─ Semi Join (EXISTS)
  └─ Anti Join (NOT EXISTS)

수직 파티셔닝
  └─ 컬럼 분할 (테이블 분할)

수평 파티셔닝
  ├─ Range (범위)
  ├─ List (값 목록)
  ├─ Hash (해시)
  └─ Composite (복합)

샤딩
  └─ 물리적 분산 (여러 서버)

Consistency (일관성)
Availability (가용성)
Partition Tolerance (분할 내성)

→ 3가지 중 2가지만 선택 가능

RDBMS: CA (일관성 + 가용성)
NoSQL: AP (가용성 + 분할 내성)

PACELC 이론
  └─ CAP 확장: Partition 시 AC, Else LC 트레이드오프

Key-Value Store
  └─ Redis, DynamoDB (빠른 조회)

Document Store
  └─ MongoDB, Couchbase (JSON 문서)

Column-Family Store
  └─ Cassandra, HBase (대용량 쓰기)

Graph Database
  └─ Neo4j, ArangoDB (관계 분석)

OLTP (운영 DB)
    ↓
  ETL (추출/변환/적재)
    ↓
  DW (데이터 웨어하우스)
    ↓
  OLAP Cube (다차원 분석)
    ↓
  BI (리포팅/대시보드)

정규화된 스키마
    ↓
스노우플레이크 스키마 (정규화)
    ↓
스타 스키마 (역정규화)
    ├─ 팩트 테이블 (측정값)
    └─ 디멘션 테이블 (차원)

데이터 웨어하우스 (구조화된 데이터)
    ↓
데이터 레이크 (원시 데이터, 모든 형식)
    ↓
레이크하우스 (DW + Lake, Delta Lake)

중앙집중 ETL → 데이터 레이크 (2010s)
    ↓
데이터 패브릭 (자동화된 통합, 메타데이터 기반)
    ↓
데이터 메시 (도메인 소유권, Data as a Product)

저장: HDFS (분산 파일 시스템)
    ↓
처리: MapReduce → Spark (인메모리)
    ↓
SQL on Hadoop: Hive / HBase
    ↓
분석: Presto/Trino, DuckDB
    ↓
스트림: Kafka, Flink (실시간 처리)
    ↓
CDC: Debezium (변경 데이터 캡처)

방법론
  ├─ SEMMA (SAS 기반)
  ├─ KDD (지식 발견)
  └─ CRISP-DM (산업 표준)

텍스트 마이닝
  └─ 토픽 모델링 (LDA 등)

WAL (Write-Ahead Logging)
    ↓
Redo/Undo 로그
  ├─ Redo: 커밋된 트랜잭션 재실행
  └─ Undo: 미완료 트랜잭션 취소
    ↓
체크포인트 (회복 시점)
    ↓
ARIES 알고리즘 (Analysis-Redo-Undo)
    ↓
PITR (Point-in-Time Recovery)

Vacuum (PostgreSQL)
  └─ Dead Tuple 정리, MVCC 부산물 관리

2PC (Two-Phase Commit)
  ├─ Prepare Phase
  └─ Commit Phase
  → 블로킹 문제

Saga 패턴
  ├─ Choreography (이벤트 기반)
  └─ Orchestration (중앙 조정)
  → 보상 트랜잭션

Percolator 모델
  └─ 분산 트랜잭션 심화 (Google)

분산DB 투명성
  ├─ 위치 투명성
  ├─ 분할 투명성
  └─ 복제 투명성

Quorum Replication
  └─ W + R > N (일관성 보장)

Vector Clock / Lamport Timestamp
  └─ 분산 시스템 인과 관계 추적

RDBMS (확장성 부족)
    +
NoSQL (일관성 부족)
    ↓
NewSQL (확장성 + ACID)
  ├─ CockroachDB (분산 SQL)
  ├─ TiDB (MySQL 호환)
  └─ Vitess (MySQL 샤딩)

백업 유형
  ├─ Full Backup (전체)
  ├─ Incremental Backup (증분)
  └─ Differential Backup (차등)

복구 방식
  ├─ 백업/복구 전략
  ├─ PITR (시점 복구)
  └─ 데이터 마이그레이션