안동민 개발노트

DBMS가 데이터를 관리하는 방식은 단순하지 않습니다. 사용자가 보는 데이터의 모습과, 디스크에 실제로 저장된 데이터의 모습은 전혀 다릅니다. DBMS는 이 둘 사이를 3단계 스키마 구조로 분리하여, 하나를 바꿔도 다른 쪽에 영향이 가지 않도록 설계되어 있습니다. 이 구조를 이해하면 DBMS가 왜 이렇게 복잡한 시스템인지, 그 복잡성이 어떤 가치를 가져오는지 알 수 있습니다.

스키마(Schema)란

스키마는 데이터베이스의 구조를 정의한 청사진입니다. 어떤 테이블이 있고, 각 테이블에 어떤 컬럼이 있으며, 컬럼의 타입은 무엇이고, 테이블 간의 관계는 어떠한지를 기술합니다.

스키마 vs 데이터

스키마 (구조)
  users 테이블 → id(정수), name(문자열), email(문자열)
  orders 테이블 → id(정수), user_id(정수), total(실수)
  관계: orders.user_id → users.id

데이터 (인스턴스)
  users: (1, '김철수', 'kim@mail.com')
  orders: (1, 1, 50000)

스키마는 시간이 지나도 잘 변하지 않지만, 데이터(인스턴스)는 매 순간 변합니다. 스키마가 틀이라면 데이터는 틀에 담긴 내용물입니다.

3단계 스키마 구조

1975년 ANSI/SPARC 위원회가 제안한 이 구조는 데이터를 세 가지 관점에서 바라봅니다. 외부(사용자), 개념(전체 조직), 내부(물리적 저장)라는 세 단계로 나누어 각 단계의 변경이 다른 단계에 전파되지 않도록 합니다.

ANSI/SPARC 3단계 구조

┌─────────────────────────────────────┐
│  사용자 A    사용자 B    사용자 C   │
└──────┬────────┬────────┬────────────┘
       │        │        │
┌──────┴────────┴────────┴─────────────┐
│          외부 스키마 (External)      │
│  뷰 A: 이름, 이메일                  │
│  뷰 B: 이름, 주문내역                │
│  뷰 C: 이름, 구매통계                │
└───────────────┬──────────────────────┘
                │  ← 논리적 데이터 독립성
┌───────────────┴──────────────────────┐
│          개념 스키마 (Conceptual)    │
│  users(id, name, email, phone)       │
│  orders(id, user_id, total, date)    │
│  FK: orders.user_id → users.id       │
└───────────────┬──────────────────────┘
                │  ← 물리적 데이터 독립성
┌───────────────┴──────────────────────┐
│          내부 스키마 (Internal)      │
│  users: B+Tree 인덱스(id)            │
│  orders: 클러스터드 인덱스(id)       │
│  페이지 크기: 8KB, 압축: zlib        │
└──────────────────────────────────────┘

외부 스키마 (External Schema)

외부 스키마는 개별 사용자나 애플리케이션이 보는 데이터의 모습입니다. 전체 데이터베이스 중 특정 사용자에게 필요한 부분만 보여주는 창의 역할을 합니다. SQL에서 VIEW가 외부 스키마를 구현하는 대표적인 방법입니다.

외부 스키마 구현 예: VIEW

-- 주문팀용 뷰: 고객 이름과 주문 내역만 표시
CREATE VIEW order_team_view AS
SELECT u.name, o.order_id, o.total, o.order_date
FROM users u
JOIN orders o ON u.id = o.user_id;

-- 마케팅팀용 뷰: 고객 이메일과 구매 통계만 표시
CREATE VIEW marketing_view AS
SELECT u.email, COUNT(o.order_id) AS order_count,
       SUM(o.total) AS total_spent
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
GROUP BY u.email;

-- 인사팀용 뷰: 고객 정보에 접근 불가
-- (VIEW가 없으므로 인사팀은 이 데이터를 볼 수 없음)

같은 데이터를 다른 관점으로 보여줄 수 있으며, VIEW에 포함되지 않은 데이터는 사용자가 접근할 수 없으므로 보안 효과도 있습니다.

하나의 데이터베이스에 외부 스키마는 여러 개 존재할 수 있습니다. 사용자마다, 애플리케이션마다 다른 외부 스키마를 가질 수 있습니다.

개념 스키마 (Conceptual Schema)

개념 스키마는 조직 전체의 데이터를 통합한 논리적 구조입니다. 데이터베이스에 어떤 테이블이 있고, 각 테이블의 컬럼은 무엇이며, 테이블 간의 관계는 어떻게 되는지, 어떤 제약 조건이 존재하는지를 정의합니다.

개념 스키마 예시

-- 테이블 정의
CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(200) UNIQUE,
    phone VARCHAR(20),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE orders (
    id INT PRIMARY KEY,
    user_id INT NOT NULL,
    total DECIMAL(10,2) CHECK (total >= 0),
    order_date DATE NOT NULL,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- 이 모든 정의가 합쳐진 것이 개념 스키마

개념 스키마는 데이터베이스당 하나만 존재합니다. DBA(데이터베이스 관리자)가 관리하며, 조직의 데이터 요구사항 전체를 반영합니다.

보통 스키마라고 하면 개념 스키마를 가리킵니다. CREATE TABLE 문으로 테이블을 정의하고, 무결성 제약 조건을 설정하는 것이 개념 스키마를 구축하는 과정입니다.

내부 스키마 (Internal Schema)

내부 스키마는 데이터가 디스크에 실제로 어떻게 저장되는지를 정의합니다. 물리적인 저장 구조를 다룹니다.

내부 스키마가 결정하는 것들

* 인덱스 구조: B+Tree, Hash, Bitmap
* 파일 구성: Heap, Sequential, Clustered
* 데이터 페이지 크기: 4KB, 8KB, 16KB
* 레코드 저장 형식: 고정 길이 / 가변 길이
* 압축 방식: zlib, LZ4, Snappy
* 파티셔닝: Range, Hash, List
* 버퍼 풀 크기: 메모리에 캐시할 페이지 수

내부 스키마 관련 SQL (MySQL)

-- 인덱스 생성 (내부 스키마 변경)
CREATE INDEX idx_users_email ON users(email);

-- 테이블 엔진 지정
CREATE TABLE logs (
    id INT PRIMARY KEY,
    message TEXT
) ENGINE=InnoDB;

-- 파티셔닝
CREATE TABLE orders (
    id INT, order_date DATE, total DECIMAL(10,2)
) PARTITION BY RANGE (YEAR(order_date)) (
    PARTITION p2022 VALUES LESS THAN (2023),
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025)
);

내부 스키마는 데이터베이스당 하나만 존재합니다. DBA가 성능 최적화를 위해 변경하는 것은 대부분 내부 스키마입니다. 인덱스를 추가하거나, 파티셔닝을 적용하거나, 저장 엔진을 변경하는 것이 모두 내부 스키마 변경입니다.

데이터 독립성

3단계 구조의 핵심 목적은 데이터 독립성(Data Independence)입니다. 한 단계의 스키마를 변경해도 다른 단계의 스키마에 영향을 주지 않는 것을 말합니다.

물리적 데이터 독립성

내부 스키마가 변해도 개념 스키마에 영향이 없는 것입니다. 내부 스키마와 개념 스키마 사이의 내부/개념 매핑이 이를 보장합니다.

물리적 데이터 독립성 예시

변경 전                          변경 후
  내부 스키마                      내부 스키마
  └ users: Heap 파일               └ users: B+Tree 클러스터
  └ 인덱스: 없음                   └ 인덱스: email에 추가

개념 스키마: 변화 없음              개념 스키마: 변화 없음
  └ users(id, name, email)          └ users(id, name, email)

SQL: 변경 불필요                   SQL: 변경 불필요
  └ SELECT * FROM users             └ SELECT * FROM users
    WHERE email = 'a@b.com'           WHERE email = 'a@b.com'

DBA가 인덱스를 추가하거나 파일 구조를 변경해도, 개발자의 SQL은 수정할 필요가 없습니다. 이것이 물리적 데이터 독립성입니다. 실현하기 비교적 쉬우며, 현대 DBMS에서 잘 지원됩니다.

논리적 데이터 독립성

개념 스키마가 변해도 외부 스키마에 영향이 없는 것입니다. 개념 스키마와 외부 스키마 사이의 외부/개념 매핑이 이를 보장합니다.

논리적 데이터 독립성 예시

변경 전                           변경 후
  개념 스키마                       개념 스키마
  └ users(id, name, email)          └ users(id, name, email, phone) ← 컬럼 추가

  외부 스키마 (뷰)                  외부 스키마 (뷰)
  └ user_view(name, email)          └ user_view(name, email) ← 변화 없음

  애플리케이션: 변화 없음           애플리케이션: 변화 없음
  └ SELECT * FROM user_view          └ SELECT * FROM user_view

테이블에 phone 컬럼을 추가해도 기존 뷰(user_view)에는 phone이 포함되지 않으므로, 이 뷰를 사용하는 애플리케이션은 영향을 받지 않습니다.

논리적 데이터 독립성은 물리적 데이터 독립성보다 실현하기 어렵습니다. 테이블을 분할하거나 병합하는 구조 변경은 뷰를 재정의해야 할 수 있기 때문입니다.

두 독립성 비교

| 구분          | 관련 스키마 | 매핑           | 실현 난이도 |
| ------------- | ----------- | -------------- | ----------- |
| 물리적 독립성 | 내부 ↔ 개념 | 내부/개념 매핑 | 쉬움        |
| 논리적 독립성 | 개념 ↔ 외부 | 외부/개념 매핑 | 어려움      |

DBMS의 주요 기능

DBMS가 제공하는 기능은 크게 세 가지로 나뉩니다.

데이터 정의 (Definition)

데이터의 구조를 정의하는 기능입니다. 테이블을 만들고, 컬럼의 타입을 지정하고, 제약 조건을 설정합니다. DDL(Data Definition Language)이 이 기능을 담당합니다.

데이터 정의 예시

-- 테이블 생성
CREATE TABLE products (
    product_id INT PRIMARY KEY,
    name VARCHAR(200) NOT NULL,
    price DECIMAL(10,2) CHECK (price > 0),
    category_id INT,
    FOREIGN KEY (category_id) REFERENCES categories(category_id)
);

-- 테이블 구조 변경
ALTER TABLE products ADD COLUMN stock INT DEFAULT 0;

-- 테이블 삭제
DROP TABLE products;

데이터 정의 기능은 데이터 사전(Data Dictionary) 또는 시스템 카탈로그(System Catalog)에 스키마 정보를 저장합니다. CREATE TABLE을 실행하면 테이블의 메타데이터(컬럼명, 타입, 제약 조건 등)가 시스템 카탈로그에 기록됩니다.

시스템 카탈로그 조회

-- MySQL: 테이블 메타정보 조회
SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, IS_NULLABLE
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = 'mydb';

-- PostgreSQL: 테이블 목록 조회
SELECT tablename FROM pg_tables
WHERE schemaname = 'public';

-- Oracle: 테이블 목록 조회
SELECT TABLE_NAME FROM USER_TABLES;

데이터 조작 (Manipulation)

데이터를 삽입, 조회, 수정, 삭제하는 기능입니다. DML(Data Manipulation Language)이 이 기능을 담당합니다. CRUD(Create, Read, Update, Delete)라고도 부릅니다.

데이터 조작 예시

-- 삽입 (Create)
INSERT INTO products (product_id, name, price) VALUES (1, '노트북', 1200000);

-- 조회 (Read)
SELECT name, price FROM products WHERE price > 500000;

-- 수정 (Update)
UPDATE products SET price = 1100000 WHERE product_id = 1;

-- 삭제 (Delete)
DELETE FROM products WHERE product_id = 1;

데이터 조작은 절차적 DML과 비절차적 DML로 나뉩니다.

절차적 vs 비절차적 DML

절차적 DML:
  "어떻게(How)" 데이터를 가져올지 명시
  한 번에 하나의 레코드를 처리
  예: 커서(Cursor)를 사용하여 행 단위 처리

비절차적 DML:
  "무엇을(What)" 원하는지만 명시
  한 번에 여러 레코드를 처리
  예: SQL의 SELECT, INSERT, UPDATE, DELETE

SQL은 비절차적 DML의 대표입니다. 사용자는 30세 이상 회원을 조회해라고만 말하면 되고, DBMS가 어떤 인덱스를 사용하고 어떤 순서로 검색할지는 옵티마이저가 결정합니다.

데이터 제어 (Control)

데이터의 정확성, 보안, 동시성을 관리하는 기능입니다. DCL(Data Control Language)과 TCL(Transaction Control Language)이 이 기능을 담당합니다.

데이터 제어 기능 상세

1. 무결성 제어 (Integrity Control)
   데이터가 올바른 상태를 유지하도록 보장
   예: PRIMARY KEY, FOREIGN KEY, CHECK, NOT NULL

2. 동시성 제어 (Concurrency Control)
   여러 사용자가 동시에 접근해도 데이터 일관성 유지
   예: 락(Lock), MVCC, 트랜잭션 격리 수준

3. 접근 제어 (Access Control)
   권한이 있는 사용자만 데이터에 접근 가능
   예: GRANT, REVOKE, ROLE

4. 복구 (Recovery)
   장애 발생 시 데이터를 일관된 상태로 복구
   예: 로그 기반 복구, 체크포인트, 백업

접근 제어 예시

-- 사용자에게 SELECT 권한 부여
GRANT SELECT ON products TO analyst_user;

-- INSERT, UPDATE 권한 부여
GRANT INSERT, UPDATE ON products TO editor_user;

-- 모든 권한 부여
GRANT ALL PRIVILEGES ON products TO admin_user;

-- 권한 회수
REVOKE INSERT ON products FROM editor_user;

-- 역할(ROLE) 기반 권한 관리
CREATE ROLE readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly;
GRANT readonly TO analyst_user;

데이터 언어

DBMS와 소통하는 언어를 데이터 언어(Data Language)라 합니다. 기능에 따라 네 가지로 분류됩니다.

DDL (Data Definition Language)

데이터의 구조를 정의, 수정, 삭제하는 언어입니다. 실행 결과는 시스템 카탈로그(데이터 사전)에 저장됩니다.

DDL 명령어

| 명령어   | 기능            | 예시                         |
| -------- | --------------- | ---------------------------- |
| CREATE   | 구조 생성       | CREATE TABLE, CREATE INDEX   |
| ALTER    | 구조 변경       | ALTER TABLE ADD COLUMN       |
| DROP     | 구조 삭제       | DROP TABLE, DROP INDEX       |
| RENAME   | 이름 변경       | RENAME TABLE old TO new      |
| TRUNCATE | 데이터 전체삭제 | TRUNCATE TABLE (구조는 유지) |

TRUNCATE는 DDL이지만 데이터를 삭제합니다. DELETE와 달리 롤백이 불가능하고, 로그를 최소한으로 남기므로 대량 삭제 시 훨씬 빠릅니다. 단, 조건 없이 테이블 전체를 비우므로 주의해야 합니다.

DML (Data Manipulation Language)

데이터를 조작(CRUD)하는 언어입니다.

DML 명령어

| 명령어 | 기능 | 특징                                   |
| ------ | ---- | -------------------------------------- |
| SELECT | 조회 | 가장 많이 사용, 데이터를 변경하지 않음 |
| INSERT | 삽입 | 새 행 추가                             |
| UPDATE | 수정 | 기존 행의 값 변경                      |
| DELETE | 삭제 | 기존 행 제거 (조건 가능, 롤백 가능)    |

SELECT는 데이터를 읽기만 하므로 DQL(Data Query Language)로 별도 분류하기도 합니다.

DCL (Data Control Language)

데이터에 대한 접근 권한을 관리하는 언어입니다.

DCL 명령어

| 명령어 | 기능      | 예시                            |
| ------ | --------- | ------------------------------- |
| GRANT  | 권한 부여 | GRANT SELECT ON users TO kim    |
| REVOKE | 권한 회수 | REVOKE SELECT ON users FROM kim |

TCL (Transaction Control Language)

트랜잭션의 시작과 끝, 중간 저장점을 관리하는 언어입니다.

TCL 명령어

| 명령어    | 기능        | 설명                        |
| --------- | ----------- | --------------------------- |
| COMMIT    | 확정        | 트랜잭션의 변경을 영구 반영 |
| ROLLBACK  | 취소        | 트랜잭션의 변경을 모두 취소 |
| SAVEPOINT | 중간 저장점 | 부분 롤백을 위한 지점 설정  |

이 네 가지 언어를 합쳐서 SQL(Structured Query Language)이라 부릅니다. SQL은 관계형 데이터베이스의 표준 언어이며, Oracle, MySQL, PostgreSQL, SQL Server 등 모든 관계형 DBMS에서 사용합니다.

SQL 언어 체계 정리

SQL ─┬─ DDL : CREATE, ALTER, DROP, TRUNCATE, RENAME
     ├─ DML : SELECT, INSERT, UPDATE, DELETE
     ├─ DCL : GRANT, REVOKE
     └─ TCL : COMMIT, ROLLBACK, SAVEPOINT

DBMS의 내부 구조

DBMS는 사용자의 SQL을 받아 데이터를 읽고 쓰는 복잡한 시스템입니다. 내부적으로 여러 모듈이 협력하여 동작합니다.

DBMS 내부 구성 요소

┌──────────────────────────────────────────────┐
│                  사용자 / 응용 프로그램      │
└──────────────┬───────────────────────────────┘
               │ SQL 질의
┌──────────────┴────────────────────────────────┐
│  질의 처리기 (Query Processor)                │
│  ┌──────────┐  ┌──────────┐  ┌────────────┐   │
│  │ 파서     │→│ 옵티마이저│→│ 실행 엔진   │   │
│  │ (Parser) │  │(Optimizer)│  │(Executor)  │  │
│  └──────────┘  └──────────┘  └────────────┘   │
└──────────────┬────────────────────────────────┘
               │
┌──────────────┴──────────────────────────────────┐
│  저장 시스템 (Storage System)                   │
│  ┌────────────┐  ┌──────────┐  ┌───────────┐    │
│  │ 버퍼 관리자 │  │ 파일 관리자│  │ 디스크 공간││
│  │(Buffer Mgr)│  │(File Mgr) │  │ 관리자    │   │
│  └────────────┘  └──────────┘  └───────────┘    │
└──────────────┬──────────────────────────────────┘
               │
┌──────────────┴─────────────────────────────────┐
│  트랜잭션 관리 (Transaction Manager)           │
│  ┌──────────┐  ┌──────────┐  ┌────────────┐    │
│  │ 동시성    │  │ 복구     │  │ 로그       │   │
│  │ 제어     │  │ 관리자   │  │ 관리자     │    │
│  └──────────┘  └──────────┘  └────────────┘    │
└────────────────────────────────────────────────┘

질의 처리기 (Query Processor)

SQL이 입력되면 가장 먼저 파서(Parser)가 SQL의 문법을 검사하고, 구조를 파싱 트리(Parse Tree)로 변환합니다. 잘못된 문법이 있으면 이 단계에서 오류를 반환합니다.

다음으로 옵티마이저(Optimizer)가 파싱 트리를 분석하여 가장 효율적인 실행 계획을 세웁니다. 어떤 인덱스를 사용할지, 어떤 순서로 조인할지, 테이블을 풀 스캔할지 인덱스 스캔할지를 결정합니다. 옵티마이저는 DBMS에서 가장 복잡하고 중요한 모듈입니다.

마지막으로 실행 엔진(Executor)이 옵티마이저가 만든 실행 계획을 따라 저장 시스템에 데이터를 요청하고, 결과를 조합하여 사용자에게 반환합니다.

SQL 처리 과정 예시

입력: SELECT name FROM users WHERE age > 30;

1. 파서: 문법 확인 → 파싱 트리 생성
2. 옵티마이저
   계획 A: Full Table Scan → 예상 비용 100
   계획 B: idx_age 사용    → 예상 비용 15
   → 계획 B 선택
3. 실행 엔진: idx_age 인덱스로 age > 30인 행 검색
4. 결과 반환: ['김철수', '이영희', ...]

저장 시스템 (Storage System)

버퍼 관리자(Buffer Manager)는 디스크의 데이터를 메모리(버퍼 풀)에 캐시합니다. 디스크 I/O는 메모리 접근보다 수만 배 느리므로, 자주 접근하는 데이터를 메모리에 올려두는 것이 성능의 핵심입니다.

파일 관리자(File Manager)는 데이터를 파일에 저장하고 읽는 역할을 합니다. 레코드를 페이지(블록) 단위로 관리하며, 데이터의 물리적 배치를 담당합니다.

트랜잭션 관리 (Transaction Manager)

동시성 제어는 여러 트랜잭션이 동시에 실행될 때 데이터의 일관성을 유지합니다. 락(Lock), 타임스탬프, MVCC 등의 기법을 사용합니다.

복구 관리자는 시스템 장애 발생 시 트랜잭션의 원자성과 지속성을 보장합니다. 로그를 기반으로 Redo와 Undo를 수행합니다.

데이터 사전과 데이터 디렉터리

데이터 사전 (Data Dictionary)

데이터 사전은 메타데이터(데이터에 대한 데이터)를 저장하는 시스템 테이블입니다. 시스템 카탈로그(System Catalog)라고도 부릅니다.

데이터 사전에 저장되는 정보

* 테이블 이름, 컬럼 이름, 데이터 타입
* 기본키, 외래키, 제약 조건
* 인덱스 정보
* 뷰 정의
* 사용자 및 권한 정보
* 통계 정보 (행 수, 카디널리티)

데이터 사전 자체도 테이블로 저장되며, SQL로 조회할 수 있습니다. 사용자가 데이터 사전을 직접 수정하는 것은 허용되지 않으며, DDL 명령을 통해 자동으로 관리됩니다. 따라서 데이터 사전은 읽기 전용입니다.

데이터 디렉터리 (Data Directory)

데이터 디렉터리는 데이터의 물리적 위치 정보를 저장합니다. 특정 데이터가 디스크의 어느 파일, 어느 블록에 저장되어 있는지를 기록합니다. 데이터 사전이 논리적 정보를 저장한다면, 데이터 디렉터리는 물리적 위치 정보를 저장합니다.

데이터 사전 vs 데이터 디렉터리

| 구분        | 데이터 사전         | 데이터 디렉터리      |
| ----------- | ------------------- | -------------------- |
| 저장 내용   | 메타데이터 (논리적) | 물리적 위치 정보     |
| 사용자 접근 | SQL로 조회 가능     | 시스템 내부 사용     |
| 수정        | DDL로만 변경        | DBMS 자동 관리       |
| 예시        | 테이블명, 컬럼 타입 | 파일 경로, 블록 번호 |

DBMS 사용자

DBMS를 사용하는 사람은 역할에 따라 세 부류로 나뉩니다.

DBMS 사용자 분류

1. 데이터베이스 관리자 (DBA)
   * 데이터베이스 설계 및 구축
   * 스키마 정의 및 변경
   * 접근 권한 관리
   * 성능 모니터링 및 튜닝
   * 백업 및 복구 전략 수립

2. 응용 프로그래머
   * 데이터베이스를 활용하는 애플리케이션 개발
   * DML을 사용하여 데이터 조작
   * 호스트 언어(Java, Python 등)에 SQL 내장

3. 최종 사용자 (End User)
   * 데이터베이스에 접근하여 정보 조회
   * 캐주얼 사용자: 비정기적으로 다양한 질의 수행
   * 초보 사용자: 미리 만들어진 화면/보고서 사용

DBMS 구성 요소 전체 정리

DBMS 핵심 구조 요약

┌──────────────────────────────────────────────────┐
│ 3단계 스키마                                     │
│  외부(뷰) ──매핑── 개념(전체) ──매핑── 내부(저장)│
├──────────────────────────────────────────────────┤
│ 데이터 독립성                                    │
│  논리적: 개념↔외부 분리   물리적: 내부↔개념 분리 │
├──────────────────────────────────────────────────┤
│ 3대 기능          │ 데이터 언어                  │
│  정의(Definition) │ DDL: CREATE, ALTER, DROP     │
│  조작(Manipulation)│ DML: SELECT, INSERT, UPDATE │
│  제어(Control)    │ DCL: GRANT, REVOKE           │
│                   │ TCL: COMMIT, ROLLBACK        │
├──────────────────────────────────────────────────┤
│ 내부 구성                                        │
│  질의 처리기: 파서 → 옵티마이저 → 실행 엔진      │
│  저장 시스템: 버퍼 관리자, 파일 관리자           │
│  트랜잭션: 동시성 제어, 복구, 로그               │
├──────────────────────────────────────────────────┤
│ 메타데이터 관리                                  │
│  데이터 사전: 논리적 메타정보 (읽기 전용)        │
│  데이터 디렉터리: 물리적 위치 정보               │
└──────────────────────────────────────────────────┘

다음 절에서는 데이터베이스 시스템의 종류와 선택 기준을 살펴보겠습니다.

DBMS의 구조와 기능