본문 바로가기
GD's IT Lectures : 기초부터 시리즈/데이터베이스(DB) 기초부터 ~

[데이터베이스(DB)] 2. 관계형 데이터 모델

by GDNGY 2023. 6. 19.

Chapter 2. 관계형 데이터 모델

관계형 데이터 모델은 데이터를 엔티티와 속성, 키를 사용한 관계로 정의하며, 이것들이 스키마 내 테이블로 표현됩니다. 이 장에서는 엔티티, 속성, 그리고 이들 간의 관계를 이해하는 것부터 시작하여, 기본 키와 외래 키의 중요성, 그리고 테이블 간의 관계 설정 방법을 배웁니다. 이후, 스키마의 개념과 그 구성 요소를 배우고, 실제 관계형 데이터베이스에서 어떻게 테이블을 생성하고 관리하는지에 대해 학습합니다. 

 

반응형

 

[Chapter 2. 관계형 데이터 모델]

 

2.1. 엔티티 및 속성

2.1.1. 엔티티와 그 특성 이해

2.1.2. 속성 정의 및 유형

2.1.3. 엔티티와 속성의 실제 예시

 

2.2. 키와 관계

2.2.1. 기본 키와 외래 키

2.2.2. 테이블 간 관계 설정

2.2.3. 키와 관계의 실제 예시

 

2.3. 관계형 스키마 및 테이블

2.3.1. 스키마 및 그 구성 요소의 개념

2.3.2. 관계형 데이터베이스에서 테이블 생성 및 관리하기

2.3.3. 스키마와 테이블의 실제 예시

2.1. 엔티티 및 속성

Chapter 2.1에서는 '엔티티와 속성'의 기본 개념을 학습합니다. 엔티티는 데이터베이스에서 표현하려는 실세계의 객체나 사건을 가리킵니다. 예를 들면, 학생, 책, 주문 등이 있습니다. 속성은 엔티티를 구성하는 세부 정보를 나타내며, 예로 학생의 경우 이름, 학번, 학과 등이 될 수 있습니다. 이 섹션에서는 이러한 개념들의 정의와 특성을 이해하고, 실제 예시를 통해 그들이 어떻게 데이터베이스에서 사용되는지를 배우게 됩니다.

2.1.1. 엔티티와 그 특성 이해

관계형 데이터베이스의 핵심 구성 요소 중 하나는 '엔티티'입니다. 엔티티는 사실상 데이터베이스에서 다루고자 하는 대상을 의미합니다. 그 대상은 사람일 수도, 물건일 수도, 혹은 사건일 수도 있습니다. 간단하게 말하면, 엔티티는 데이터베이스에서 정보를 저장하고자 하는 모든 것을 가리키는 개념입니다.

 

예를 들어, 우리가 학교 데이터베이스를 만들고 있다고 가정해 봅시다. 그러면 '학생', '교수', '과목', '강의' 등이 각각 엔티티가 될 수 있습니다. 여기서 '학생'이라는 엔티티는 학교 내의 모든 학생을 개별적으로 표현하며, 각 학생은 자신만의 고유한 속성 값을 가지게 됩니다.

 

엔티티는 관계형 데이터베이스에서 '테이블'로 표현되며, 테이블의 각 '행'은 특정 엔티티의 인스턴스를 의미합니다. 예를 들어, '학생' 엔티티는 '학생' 테이블로 표현되고, 테이블의 각 행은 특정 학생을 나타냅니다.

 

아래는 '학생' 엔티티를 SQL을 사용하여 테이블로 만드는 예제입니다:

 

[예제] 

CREATE TABLE Student (
    StudentID INT PRIMARY KEY,
    FirstName VARCHAR(100),
    LastName VARCHAR(100),
    Major VARCHAR(100),
    EnrollmentYear INT
);

 

이 SQL 쿼리는 '학생' 테이블을 생성합니다. 여기서 각 학생은 고유한 'StudentID'를 가지며, 이는 테이블의 기본 키로 사용됩니다. 또한 'FirstName', 'LastName', 'Major', 'EnrollmentYear' 등의 속성도 가지게 됩니다.

 

이렇게 엔티티를 이해하고 데이터베이스에 표현하는 것은 데이터를 구조화하고, 효율적으로 관리하는데 중요한 첫걸음입니다. 엔티티와 그 특성을 올바르게 이해하는 것은, 데이터베이스의 효율성과 정확성을 보장하며, 데이터 중복성을 최소화하는 데 도움이 됩니다.

 

엔티티는 그 자체로 의미가 있을 뿐만 아니라 다른 엔티티와의 관계에서도 중요한 역할을 합니다. 예를 들어, '학생' 엔티티는 '강의' 엔티티와 관계를 맺을 수 있습니다. 이 관계는 '학생은 강의를 듣는다'와 같이 표현될 수 있습니다.

 

또한, 각 엔티티는 고유한 식별자를 가지는데, 이를 '기본 키'라고 합니다. '학생' 엔티티에서는 학번이 이 역할을 하며, '강의' 엔티티에서는 강의 코드가 이 역할을 합니다. 기본 키는 각 엔티티 인스턴스를 고유하게 식별하는 역할을 하기 때문에 중복될 수 없습니다.

 

이번에는 '강의' 엔티티를 SQL을 사용하여 테이블로 만드는 예제를 살펴봅시다:

 

[예제] 

CREATE TABLE Lecture (
    LectureID INT PRIMARY KEY,
    LectureName VARCHAR(100),
    Professor VARCHAR(100),
    Credit INT
);

 

이 SQL 쿼리는 '강의' 테이블을 생성하며, 각 강의는 고유한 'LectureID'를 가지게 됩니다. 또한 'LectureName', 'Professor', 'Credit' 등의 속성도 가지게 됩니다. 

 

결론적으로, 엔티티는 데이터베이스에서 정보를 표현하는 기본 단위이며, 각 엔티티는 고유한 속성과 식별자를 가지게 됩니다. 그리고 엔티티는 서로 관계를 맺을 수 있으며, 이 관계는 데이터의 복잡성을 관리하고, 데이터의 일관성과 무결성을 유지하는데 중요한 역할을 합니다. 이런 이유로, 엔티티와 그 특성을 이해하는 것은 데이터베이스 설계 및 사용에서 기본적이면서도 중요한 단계입니다. 

 

'엔티티'와 '테이블'은 자주 혼동되는 개념인데, 둘 사이에는 중요한 차이가 있습니다. '엔티티'는 논리적인 개념이며, 실세계의 객체나 사건을 나타냅니다. 반면 '테이블'은 이러한 엔티티를 데이터베이스에 물리적으로 저장하는 방법입니다.

 

따라서 데이터베이스 설계 과정에서는 먼저 엔티티를 식별하고 그 관계를 설정한 후, 이를 바탕으로 테이블을 정의하는 순서로 진행하게 됩니다. 이 과정에서 엔티티와 테이블의 차이를 이해하는 것이 중요합니다.

 

이를 설명하는 예시를 더 보여드리겠습니다. '학생'이라는 엔티티가 있다고 가정해 봅시다. 이 엔티티는 실세계의 '학생'이라는 개념을 나타내며, '이름', '학번', '학과' 등의 속성을 가지게 됩니다. 하지만 이런 '학생' 엔티티를 실제 데이터베이스에 저장하기 위해서는 '테이블'이라는 구조를 사용해야 합니다.

 

따라서 '학생' 엔티티를 'Student'라는 테이블로 변환하게 되고, 이 테이블은 각 학생의 '이름', '학번', '학과'를 열(column)로 가지게 됩니다. 그리고 각 학생의 정보는 행(row)으로 표현되게 됩니다.

 

즉, '엔티티'는 데이터의 논리적인 개념이며, '테이블'은 이런 데이터를 물리적으로 표현하고 저장하는 구조를 나타냅니다. 이런 차이를 이해하는 것은 엔티티를 테이블로 올바르게 변환하고, 데이터를 효율적으로 관리하는 데 중요한 역할을 합니다.

 

2.1.2. 속성 정의 및 유형

데이터베이스에서 '속성'이란 엔티티를 구성하는 여러 특성 중 하나를 말합니다. 예를 들어, '학생'이라는 엔티티에는 '이름', '학번', '학과' 등의 속성이 있을 수 있습니다. 이러한 속성들은 해당 엔티티의 고유한 특징을 나타내며, 각 속성은 고유한 값을 가지게 됩니다.

 

속성의 유형은 크게 두 가지로 나뉩니다: 단일 값 속성과 다중 값 속성. '단일 값 속성'이란 하나의 엔티티가 하나의 값만 가질 수 있는 속성을 말하며, 반면에 '다중 값 속성'은 하나의 엔티티가 여러 개의 값을 가질 수 있는 속성을 말합니다. 예를 들어, '학번'은 학생 한 명이 하나의 학번만 가지므로 단일 값 속성이고, '수강 과목'은 학생 한 명이 여러 개의 과목을 수강할 수 있으므로 다중 값 속성입니다.

 

데이터베이스에서 속성을 정의할 때는 해당 속성의 데이터 유형을 명시해야 합니다. 데이터 유형은 속성이 가질 수 있는 값의 범위와 형태를 결정하며, 대표적으로 문자열, 정수, 실수, 날짜/시간 등의 데이터 유형이 있습니다.

 

SQL을 사용하여 테이블을 생성하고 속성을 정의하는 예를 들어보겠습니다. 다음은 '학생' 테이블을 생성하고, '이름', '학번', '학과'라는 속성을 정의하는 SQL 쿼리입니다:

 

[예제] 

CREATE TABLE Student (
    name VARCHAR(20),
    student_number INT,
    department VARCHAR(30)
);

 

이 쿼리는 'Student'라는 이름의 테이블을 생성하고, 'name', 'student_number', 'department'라는 속성을 정의하며, 각각의 속성은 문자열, 정수, 문자열 데이터 유형을 가집니다. 'VARCHAR'는 가변 길이의 문자열을 나타내며, 괄호 안의 숫자는 최대 길이를 나타냅니다. 'INT'는 정수를 나타냅니다. 

 

이처럼, 속성을 정의할 때는 해당 속성의 이름, 데이터 유형, 그리고 필요에 따라 다른 제약 조건들을 명시해야 합니다. 이는 데이터의 일관성과 정확성을 유지하는 데 중요한 역할을 합니다.

 

조건들 중에서도 'NOT NULL'과 'UNIQUE'가 있습니다. 'NOT NULL'은 해당 속성이 반드시 값을 가져야 함을 의미하고, 'UNIQUE'는 해당 속성의 값이 테이블 내에서 유일해야 함을 의미합니다.

 

이를 반영하여 위의 '학생' 테이블을 다시 정의해보면 다음과 같이 됩니다:


[예제] 

CREATE TABLE Student (
    name VARCHAR(20) NOT NULL,
    student_number INT UNIQUE,
    department VARCHAR(30)
);

 

위의 SQL 쿼리는 'name' 속성은 반드시 값이 있어야 하며('NOT NULL'), 'student_number' 속성의 값은 테이블 내에서 유일해야 함('UNIQUE')을 명시합니다. 

 

또한, 테이블의 속성 중 일부를 묶어서 '복합 키'를 만들 수도 있습니다. 복합 키는 두 개 이상의 속성을 합친 것으로, 각각의 속성 값만으로는 유일성이 보장되지 않지만 그 조합으로는 유일성이 보장되는 경우에 사용됩니다. 예를 들어, '학생' 테이블에서 '이름'과 '학과'를 합쳐서 복합 키를 만들 수 있습니다. 이 경우, 같은 학과의 학생 중에서는 같은 이름을 가질 수 없습니다.

 

속성의 데이터 유형은 해당 속성이 가질 수 있는 데이터의 형태와 범위를 제한합니다. 대표적인 데이터 유형으로는 '정수형(INT)', '문자열(VARCHAR)', '날짜형(DATE)', '실수형(FLOAT)' 등이 있습니다. 데이터 유형을 명시하면 데이터의 일관성을 유지하고 검색 성능을 향상할 수 있습니다. 

 

또한, 속성의 유형에 따라서 해당 속성에 특정 연산들이 가능하게 됩니다. 예를 들어, '정수형' 속성에는 사칙연산이 가능하고, '문자열' 속성에는 문자열 연결 연산이 가능합니다. '날짜형' 속성에는 날짜 간의 차이를 구하는 연산이 가능합니다.

 

다음은 '학생' 테이블에서 '입학일'과 '현재 날짜' 사이의 차이를 구하는 SQL 쿼리의 예입니다:

 

[예제] 

SELECT name, DATEDIFF(CURDATE(), entrance_date) AS days_in_school
FROM Student;

 

이 SQL 쿼리는 학생들의 이름과 입학일로부터 현재까지의 날짜 차이를 계산하여 반환합니다.

 

속성의 데이터 유형에 따라서 데이터의 효율적인 저장과 조회, 그리고 데이터의 무결성을 보장하는데 중요한 역할을 합니다. 예를 들어, 숫자로만 이루어진 데이터를 '문자열'로 저장하는 것보다는 '정수형'으로 저장하는 것이 메모리 공간을 더 효율적으로 사용할 수 있습니다. 또한, 날짜와 시간 관련 데이터를 '문자열'로 저장하면 날짜나 시간의 계산이 복잡해지고 오류가 발생하기 쉬워집니다. 이러한 이유로, 각 속성의 적절한 데이터 유형을 선택하는 것은 중요합니다.

 

마지막으로, 속성의 유형에 따라서 해당 속성에 적용 가능한 인덱스의 유형이 결정됩니다. 인덱스는 데이터의 빠른 조회를 위한 자료구조로, 특정 속성의 데이터 유형에 따라서 적절한 인덱스 유형이 달라집니다. 예를 들어, 범위 검색이 빈번한 숫자형 속성에는 B-Tree 인덱스를, 문자열의 일부만을 이용한 검색이 필요한 문자열 속성에는 풀텍스트 인덱스를 사용하면 조회 성능을 향상할 수 있습니다.

 

다음은 '학생' 테이블의 '이름' 속성에 풀텍스트 인덱스를 생성하는 SQL 쿼리의 예입니다:

 

[예제] 

CREATE FULLTEXT INDEX idx_name
ON Student (name);

 

이 SQL 쿼리는 '학생' 테이블의 '이름' 속성에 풀텍스트 인덱스를 생성합니다. 이로써 '이름' 속성에 대한 부분 일치 검색이 빠르게 이루어질 수 있습니다.

2.2. 키와 관계

키(Key)와 관계(Relationship)는 데이터베이스의 핵심 구성 요소입니다. 키는 데이터의 고유성과 검색을 지원하며, 데이터 사이의 연결을 위해 사용됩니다. 기본 키(Primary Key)는 각 레코드를 유일하게 식별하는 역할을 하며, 외래 키(Foreign Key)는 다른 테이블의 레코드를 참조합니다. 이들 키를 이용하여 관계형 데이터베이스에서는 복잡한 데이터 간 관계를 모델링하고, 무결성을 보장합니다. 

2.2.1. 기본 키와 외래 키

기본 키와 외래 키는 관계형 데이터베이스에서 데이터 레코드를 식별하고 연결하는 중요한 역할을 담당합니다. 

  • 기본 키(Primary Key) : 테이블에서 각 행을 고유하게 식별하는 열입니다. 이는 두 가지 중요한 규칙을 따릅니다: 고유성과 비공백입니다. 즉, 기본 키 필드의 값은 고유하며 NULL 값을 허용하지 않습니다. 이로 인해 데이터베이스는 모든 행을 명확하게 식별하고 찾을 수 있습니다.

다음은 기본 키를 사용하여 테이블을 생성하는 SQL 쿼리의 예입니다.

 

[예제] 

CREATE TABLE Students (
    ID INT PRIMARY KEY,
    Name VARCHAR(100),
    Age INT,
    Grade INT
);

 

이 예제에서 ID는 기본 키로 설정되어 있으며, 각 학생은 고유한 ID로 식별됩니다.

  • 외래 키(Foreign Key) : 다른 테이블의 기본 키를 참조하는 테이블의 필드나 컬렉션입니다. 이는 두 테이블 간에 관계를 설정하며, 관계형 데이터베이스에서 관계의 기본적인 수단입니다. 외래 키는 참조 무결성을 보장합니다, 즉, 외래 키 값은 반드시 참조하는 테이블의 기본 키 값 중 하나이거나 NULL이어야 합니다.

외래 키를 포함하는 SQL 쿼리 예제는 다음과 같습니다.

[예제] 

CREATE TABLE Enrollments (
    StudentID INT,
    CourseID INT,
    Grade INT,
    PRIMARY KEY (StudentID, CourseID),
    FOREIGN KEY (StudentID) REFERENCES Students(ID),
    FOREIGN KEY (CourseID) REFERENCES Courses(ID)
);

 

이 예제에서 Enrollments 테이블에는 두 개의 외래 키 StudentID와 CourseID가 있습니다. 각각 Students와 Courses 테이블의 기본 키를 참조합니다. 이렇게 하면 학생이 등록한 강좌와 강좌에 등록한 학생을 쉽게 찾을 수 있습니다. 

 

기본 키는 데이터의 중복을 방지합니다. 예를 들어, 학생 테이블에서 고유한 학번을 통해 각 학생을 식별할 수 있습니다. 만약 이 기본 키가 없다면, 이름이 같은 학생이 여러 명 있을 수 있으며 이는 혼란을 초래하게 될 것입니다. 기본 키를 사용함으로써 데이터베이스는 각 학생을 고유하게 식별할 수 있게 되며, 이를 통해 데이터 무결성을 보장합니다.

 

외래 키는 데이터베이스 간의 관계를 형성하고 연결성을 제공합니다. 외래 키를 통해 관련된 정보가 저장된 두 개의 테이블을 쉽게 연결할 수 있습니다. 예를 들어, 학생과 강좌 테이블을 연결하여 특정 학생이 등록한 강좌를 찾거나, 특정 강좌에 등록한 학생을 찾을 수 있습니다. 이는 데이터 조회를 간편하게 하며, 관련 데이터를 쉽게 찾을 수 있게 합니다.

 

이러한 키와 관계의 개념은 관계형 데이터베이스에서 중요한 역할을 합니다. 하지만 키와 관계만으로는 부족합니다. 각 키와 관계를 적절하게 정의하고 이를 통해 효율적인 데이터 관리를 하기 위해서는 이를 기반으로 한 스키마 설계가 중요합니다.

 

예를 들어, 기본 키를 선택할 때에는 고유하며 NULL이 아닌 값을 가져야 합니다. 외래 키는 참조 무결성을 보장해야 하며, 이를 위해 외래 키 필드는 반드시 참조하는 테이블의 기본 키 값을 가져야 합니다. 이렇게 키와 관계를 신중하게 선택하고 정의하는 것이 관계형 데이터베이스 설계의 핵심입니다.

 

2.2.2. 테이블 간 관계 설정

데이터베이스에서 테이블 간의 관계를 설정하는 것은 매우 중요한 작업입니다. 테이블 간의 관계를 설정함으로써, 서로 다른 테이블의 데이터를 연관시키고, 데이터의 무결성을 보장하며, 중복된 데이터를 최소화할 수 있습니다. 그렇다면 이제 테이블 간의 관계를 어떻게 설정하는지에 대해 살펴봅시다.

 

기본적으로, 관계형 데이터베이스에서는 두 가지 주요한 테이블 관계가 있습니다: '일대일' 관계와 '일대다' 관계입니다. 물론 '다대다' 관계도 있지만, 이는 보통 '일대다' 관계를 사용하여 모델링 됩니다.

 

'일대일' 관계는 한 테이블의 각 레코드가 다른 테이블의 정확히 하나의 레코드와만 연결되는 경우를 말합니다. 예를 들어, 우리가 '사람' 테이블과 '여권' 테이블을 가지고 있다고 가정해봅시다. 각 사람은 오직 하나의 여권만 가질 수 있으며, 각 여권 역시 한 사람에게만 발급될 수 있습니다. 이는 '일대일' 관계의 좋은 예시입니다.

 

반면에 '일대다' 관계는 한 테이블의 레코드가 다른 테이블의 여러 레코드와 연결될 수 있는 경우를 말합니다. 예를 들어, '교사' 테이블과 '학생' 테이블을 생각해보면, 한 명의 교사는 여러 명의 학생을 지도할 수 있지만, 각 학생은 한 명의 교사에게만 지도받을 수 있습니다. 이는 '일대다' 관계의 전형적인 예입니다. 

 

이제 SQL 쿼리를 사용해서 이런 관계를 어떻게 설정하는지 알아보겠습니다.

 

[예제] 

-- 사람 테이블 생성
CREATE TABLE Person (
    ID INT PRIMARY KEY,
    Name VARCHAR(100),
    PassportID INT
);

-- 여권 테이블 생성
CREATE TABLE Passport (
    ID INT PRIMARY KEY,
    IssueDate DATE,
    PersonID INT,
    FOREIGN KEY (PersonID) REFERENCES Person(ID)
);

-- 교사와 학생 테이블 생성
CREATE TABLE Teacher (
    ID INT PRIMARY KEY,
    Name VARCHAR(100)
);

CREATE TABLE Student (
    ID INT PRIMARY KEY,
    Name VARCHAR(100),
    TeacherID INT,
    FOREIGN KEY (TeacherID) REFERENCES Teacher(ID)
);

 

위의 SQL 쿼리를 보면, 우리는 FOREIGN KEY 구문을 사용하여 외래키를 정의하고, 이를 통해 테이블 간의 관계를 설정하였습니다. 이렇게 하면, 여권 테이블의 각 레코드는 사람 테이블의 특정 레코드를 참조하게 되며, 학생 테이블의 각 레코드는 교사 테이블의 특정 레코드를 참조하게 됩니다. 

 

그런데 주의해야 할 점은, 이 외래키는 참조 무결성을 보장합니다. 즉, 여권 테이블에 있는 PersonID는 반드시 사람 테이블의 ID에 존재해야 하며, 학생 테이블의 TeacherID는 반드시 교사 테이블의 ID에 존재해야 합니다. 이러한 참조 무결성은 데이터의 일관성을 보장하며, 중복 데이터를 방지합니다.

 

예를 들어, 다음과 같은 SQL 쿼리를 실행하면 오류가 발생합니다.

 

[예제] 

-- 잘못된 여권 레코드 추가
INSERT INTO Passport(ID, IssueDate, PersonID) VALUES(1, '2023-01-01', 100);

 

이 쿼리는 PersonID 100을 참조하는 여권 레코드를 추가하려고 시도합니다. 그런데, 만약 사람 테이블에 ID가 100인 레코드가 없다면 이 쿼리는 실패하게 됩니다. 왜냐하면 외래키는 반드시 존재하는 기본 키를 참조해야 하기 때문입니다. 이렇게 하면, 잘못된 데이터가 데이터베이스에 입력되는 것을 방지할 수 있습니다. 

 

반대로, 만약 외래 키가 참조하는 기본 키 레코드가 삭제되려고 한다면, 그것 역시 허용되지 않습니다. 왜냐하면 그러면 외래 키가 참조하는 레코드가 없어지게 되어, 데이터의 무결성이 깨지게 되기 때문입니다. 예를 들어, 다음과 같은 쿼리는 실패하게 됩니다. 


[예제] 

-- 잘못된 사람 레코드 삭제
DELETE FROM Person WHERE ID = 1;

 

만약 여권 테이블에 ID가 1인 사람을 참조하는 레코드가 있다면, 위의 쿼리는 실패하게 됩니다. 왜냐하면 그렇게 되면 여권 테이블에는 존재하지 않는 사람을 참조하는 레코드가 생기게 되어, 데이터의 무결성이 깨지게 되기 때문입니다.

 

이처럼, 테이블 간의 관계를 설정하는 것은 데이터의 무결성을 보장하고, 중복 데이터를 최소화하는데 매우 중요한 역할을 합니다. 이에 대해 이해하는 것은 데이터베이스를 사용하는 데 있어서 필수적인 기초 지식입니다.

 

그러나 우리는 데이터베이스에서 관계를 관리하기 위해 이러한 제약을 설정하면서도 유연성을 유지해야 하는 경우가 있습니다. 예를 들어, 사람이 여권을 잃어버릴 수 있고, 그 사람의 여권 기록이 데이터베이스에서 삭제될 수 있습니다. 이런 경우, 관련된 사람의 레코드를 유지하면서 여권 레코드만을 안전하게 삭제할 수 있는 방법이 필요합니다. 이런 문제를 해결하기 위해 SQL은 ON DELETE CASCADE와 같은 다양한 옵션을 제공합니다.

 

예를 들어, 다음과 같이 여권 테이블을 정의할 수 있습니다.

 

[예제] 

CREATE TABLE Passport (
    ID INT PRIMARY KEY,
    IssueDate DATE,
    PersonID INT,
    FOREIGN KEY (PersonID)
    REFERENCES Person(ID)
    ON DELETE CASCADE
);

 

여기서 ON DELETE CASCADE 옵션은 사람 레코드가 삭제될 때 해당 사람에게 발급된 여권 레코드도 함께 삭제되도록 설정하는 것입니다. 이렇게 하면, 사람이 여권을 잃어버렸을 때, 해당 사람의 여권 레코드를 안전하게 삭제할 수 있습니다.

 

또한, 데이터베이스는 다대다 관계를 설정하는 것도 가능합니다. 예를 들어, 한 사람이 여러 대의 차를 소유하고, 한 대의 차를 여러 사람이 공유할 수 있는 상황을 표현할 수 있습니다. 이를 위해 테이블 간의 관계를 설정할 때는 중간 테이블이라는 것을 사용합니다.

 

이처럼, 테이블 간의 관계를 설정하는 것은 데이터베이스 설계에서 매우 중요한 부분입니다. 이에 대한 이해는 복잡한 데이터베이스를 효과적으로 설계하고 관리하는 능력에 큰 도움이 됩니다.

 

중간 테이블은 일반적으로 두 개의 주 테이블 사이에 다대다 관계를 만들기 위한 목적으로 사용됩니다. 이 테이블에는 두 주 테이블의 기본 키를 외래 키로 가진 두 개의 필드와, 필요에 따라 추가 정보를 저장할 수 있는 다른 필드들이 포함될 수 있습니다.

 

예를 들어, 'Person' 테이블과 'Car' 테이블 사이에 다대다 관계를 설정하려면 다음과 같이 'Ownership'라는 중간 테이블을 만들 수 있습니다.

 

[예제] 

CREATE TABLE Ownership (
    PersonID INT,
    CarID INT,
    OwnershipStart DATE,
    OwnershipEnd DATE,
    PRIMARY KEY (PersonID, CarID),
    FOREIGN KEY (PersonID) REFERENCES Person(ID),
    FOREIGN KEY (CarID) REFERENCES Car(ID)
);

 

여기서 'Ownership' 테이블의 기본 키는 'PersonID'와 'CarID'의 조합입니다. 이 두 필드는 각각 'Person' 테이블과 'Car' 테이블을 참조하는 외래 키이며, 이를 통해 한 사람이 여러 대의 차를 소유하고, 한 대의 차가 여러 사람에게 소유될 수 있는 다대다 관계를 표현할 수 있습니다. 추가로, 'OwnershipStart'와 'OwnershipEnd' 필드를 통해 차량 소유권이 시작되고 끝나는 시점을 표현할 수 있습니다.

 

테이블 간 관계를 설정하는 이런 방식은 데이터의 일관성을 유지하고, 중복을 최소화하며, 데이터 관리를 더욱 효율적으로 만드는 데 큰 도움이 됩니다. 더 복잡한 경우에는 더 많은 테이블과 관계를 설정해야 하지만, 기본적인 원리는 동일합니다. 이런 실용적인 기법들은 데이터베이스 설계의 핵심이며, 데이터를 효과적으로 다루는 데 필요한 중요한 도구입니다.

 

마지막으로, SQL을 이용하여 실제로 테이블 간의 관계를 설정하는 방법에 대해 설명하겠습니다.

 

먼저, 관계를 설정할 두 테이블이 각각 있어야 합니다. 'Person' 테이블과 'Car' 테이블이 있다고 가정해봅시다.

 

[예제] 

CREATE TABLE Person (
    ID INT PRIMARY KEY,
    Name VARCHAR(100),
    Age INT
);

CREATE TABLE Car (
    ID INT PRIMARY KEY,
    Model VARCHAR(100),
    Year INT
);

 

그런 다음에, 외래 키 제약을 사용하여 이 두 테이블 사이의 관계를 정의할 수 있습니다. 예를 들어, 각 사람이 한 대의 차를 가지고 있다고 가정하면, 'Person' 테이블에 'CarID'라는 새로운 열을 추가하고, 이를 'Car' 테이블의 'ID' 열을 참조하는 외래 키로 설정할 수 있습니다.

 

[예제] 

ALTER TABLE Person
ADD CarID INT,
ADD FOREIGN KEY (CarID) REFERENCES Car(ID);

 

이제 'Person' 테이블의 각 행은 'Car' 테이블의 특정 행을 참조하게 됩니다. 즉, 각 사람이 어떤 차를 가지고 있는지 알 수 있게 됩니다. 이런 방식으로 데이터베이스 스키마를 확장하고 관계를 설정함으로써, 우리는 더 복잡한 질의와 데이터 분석을 수행할 수 있게 됩니다.

 

다만, 이 예제는 매우 단순화된 것이며, 실제로는 더 복잡한 관계와 제약 조건을 다룰 수 있어야 합니다. 예를 들어, 한 사람이 여러 대의 차를 가질 수도 있고, 한 대의 차가 여러 사람에게 소유될 수도 있습니다. 이런 경우에는 중간 테이블을 사용하여 다대다 관계를 표현할 수 있습니다.

 

이렇게 데이터베이스에 관계를 설정하는 과정은 데이터의 구조를 이해하고, 데이터를 효과적으로 관리하는 데 매우 중요합니다. 이 과정을 통해, 우리는 다양한 유형의 질의를 수행하고, 복잡한 분석을 수행하며, 데이터의 일관성을 유지할 수 있게 됩니다.

 

아래의 예제는 'Orders' 테이블과 'Customers' 테이블 사이의 관계를 설정합니다.

 

각 주문은 특정 고객에게 속하므로, 'Orders' 테이블에 'CustomerID'라는 열을 추가하여, 이 열을 'Customers' 테이블의 'ID'열을 참조하는 외래 키로 설정할 수 있습니다. 

 

먼저, 두 테이블을 생성해봅시다:

 

[예제] 

CREATE TABLE Customers (
    ID INT PRIMARY KEY,
    Name VARCHAR(100),
    Email VARCHAR(100)
);

CREATE TABLE Orders (
    ID INT PRIMARY KEY,
    OrderDate DATE,
    Amount DECIMAL(8, 2)
);

 

그 다음, 'Orders' 테이블에 'CustomerID' 열을 추가하고, 외래 키 제약 조건을 설정합니다:

[예제] 

ALTER TABLE Orders
ADD CustomerID INT,
ADD FOREIGN KEY (CustomerID) REFERENCES Customers(ID);

 

이제, 각 주문은 특정 고객을 참조합니다. 이 관계를 통해, 우리는 특정 고객의 모든 주문을 찾거나, 특정 주문이 어떤 고객에게 속하는지 등의 질의를 쉽게 수행할 수 있습니다.

 

앞서 말했듯이, 이 예제는 매우 단순화된 것이며 실제로는 더 복잡한 관계와 제약 조건을 다룰 수 있습니다. 예를 들어, 하나의 주문이 여러 고객에게 속할 수 있거나, 하나의 고객이 여러 주문을 가질 수 있습니다. 이런 경우에는 중간 테이블을 이용하여 다대다 관계를 표현할 수 있습니다.

 

이런 방식으로 테이블 간의 관계를 설정하는 것은 관계형 데이터베이스의 핵심 요소 중 하나입니다. 데이터의 구조를 이해하고, 데이터를 효율적으로 관리하고, 복잡한 질의를 수행하는 데 있어 매우 중요한 과정입니다. 

 

2.2.3. 키와 관계의 실제 예시

우리는 이미 'Customers'와 'Orders'라는 두 테이블을 만들어 두고, 'Orders' 테이블에서 'Customers' 테이블을 참조하는 외래 키를 설정했습니다. 이제 이런 관계를 활용해서 어떤 유용한 질의를 만들어 볼 수 있는지 알아봅시다.

 

예를 들어, 우리는 특정 고객의 모든 주문을 조회하고 싶을 수 있습니다. 이런 질의는 아래와 같이 작성할 수 있습니다:

 

[예제] 

SELECT Orders.ID, Orders.OrderDate, Orders.Amount
FROM Orders
JOIN Customers ON Orders.CustomerID = Customers.ID
WHERE Customers.Name = 'John Doe';

 

이 질의는 'John Doe'라는 이름의 고객이 한 모든 주문의 ID, 주문 날짜, 주문 금액을 반환합니다. 이렇게 JOIN 연산을 이용하면 두 테이블 간의 관계를 활용해서 원하는 정보를 얻을 수 있습니다. 

 

이외에도, 외래 키를 이용하면 다양한 유형의 질의를 만들 수 있습니다. 예를 들어, 주문 금액이 특정 금액 이상인 모든 고객을 찾거나, 특정 기간 동안 가장 많은 주문을 한 고객을 찾는 등의 질의를 만들 수 있습니다. 이런 질의를 만들려면, SELECT, FROM, WHERE, JOIN 등의 SQL 구문을 적절히 조합해야 합니다.

 

외래 키와 관계를 이해하고 활용하는 것은 관계형 데이터베이스를 다루는 데 있어 매우 중요한 능력입니다. 외래 키를 통해 서로 다른 테이블 사이에 연결고리를 만들어, 테이블 사이를 자유롭게 이동하면서 원하는 정보를 추출할 수 있게 됩니다. 

 

관계형 데이터베이스의 테이블 간 관계 설정과 키 사용에 대한 흥미로운 예시로는, 데이터의 무결성을 유지하는 데도 중요한 역할을 합니다. 예를 들어, 'Orders' 테이블의 'CustomerID' 외래 키는 'Customers' 테이블의 'ID' 기본 키를 참조합니다. 만약 'Customers' 테이블에서 어떤 행을 삭제하려고 하면, 그 'ID'를 참조하는 'Orders' 테이블의 행이 있는지 확인하게 됩니다. 만약 참조하는 행이 있다면, 해당 행을 삭제하려는 작업은 거부되어 데이터의 무결성이 보장됩니다. 이와 같이, 외래 키는 관계형 데이터베이스에서 데이터의 무결성을 유지하는 데 중요한 도구입니다.

 

이제, 실무에서는 이런 개념을 어떻게 활용하는지 알아보겠습니다. 우리의 데이터베이스에는 'Customers'와 'Orders' 외에도 다른 테이블들이 있을 수 있습니다. 예를 들어, 'Products'라는 테이블이 있고, 'Orders' 테이블이 'Products' 테이블을 참조할 수 있습니다. 이럴 경우, 고객이 어떤 제품을 언제 주문했는지, 그리고 그 주문에 대한 정보를 얻는 등의 다양한 질의를 만들 수 있습니다.

 

예를 들어, 특정 제품을 가장 많이 주문한 고객을 찾는 질의는 아래와 같이 작성할 수 있습니다:

 

[예제] 

SELECT Customers.Name, COUNT(Orders.ID) AS OrderCount
FROM Customers
JOIN Orders ON Customers.ID = Orders.CustomerID
JOIN Products ON Orders.ProductID = Products.ID
WHERE Products.Name = 'Product X'
GROUP BY Customers.Name
ORDER BY OrderCount DESC
LIMIT 1;

 

이 질의는 'Product X'라는 제품을 가장 많이 주문한 고객의 이름과 주문 횟수를 반환합니다.

 

테이블 간의 관계 설정은 데이터베이스의 설계와 쿼리 최적화에 깊은 영향을 미칩니다. 앞서 설명했던 예제에서도 볼 수 있듯이, 관계 설정을 통해 데이터를 효율적으로 구조화하고, 필요한 정보를 빠르게 검색할 수 있습니다. 다음은 'Orders' 테이블에 'ShippedDate'라는 새로운 속성을 추가하고, 'Product X'를 주문하고 아직 발송되지 않은 주문을 찾는 질의입니다:

 

[예제] 

ALTER TABLE Orders
ADD ShippedDate DATE;

SELECT Orders.ID
FROM Orders
JOIN Products ON Orders.ProductID = Products.ID
WHERE Products.Name = 'Product X' AND Orders.ShippedDate IS NULL;

 

'ALTER TABLE' 문은 테이블에 새로운 속성을 추가하는 데 사용됩니다. 이렇게 해서 'Orders' 테이블에 'ShippedDate' 속성이 추가되었습니다. 이어서, 'Product X'를 주문하고 아직 발송되지 않은 주문을 찾는 질의를 실행합니다. 'IS NULL' 조건은 'ShippedDate' 속성이 아직 설정되지 않은, 즉 아직 발송되지 않은 주문을 찾는 데 사용됩니다.

 

이렇게 테이블 간의 관계 설정과 기본 키, 외래 키를 이해하고 활용하면, 복잡한 비즈니스 요구 사항에 대응하는 데이터베이스를 설계하고 관리할 수 있습니다. 이번 섹션에서 배운 내용을 바탕으로, 여러분의 데이터베이스 설계 및 쿼리 작성 능력을 한 단계 끌어올릴 수 있을 것입니다.

 

마지막으로, 테이블 간의 관계를 설정하는 것은 데이터베이스 구조를 보다 유연하고 강력하게 만들 수 있습니다. 예를 들어, 만약 'Customers' 테이블과 'Orders' 테이블이 있고, 각 주문이 어떤 고객에게 속하는지 표현하려면 어떻게 해야 할까요? 이를 위해 우리는 'Orders' 테이블에 'CustomerID'라는 외래 키를 추가할 수 있습니다.

 

[예제] 

ALTER TABLE Orders
ADD COLUMN CustomerID INT;

 

이제 'CustomerID'를 사용하여 'Orders' 테이블과 'Customers' 테이블을 연결할 수 있습니다. 즉, 'CustomerID'는 'Orders' 테이블의 각 레코드가 어떤 고객에게 속하는지를 지정합니다. 이런 식으로 외래 키를 사용하면 테이블 간의 관계를 설정하고, 복잡한 데이터베이스 스키마를 쉽게 구현할 수 있습니다.

 

하지만 외래 키를 사용할 때는 주의가 필요합니다. 외래 키는 참조하는 테이블의 기본 키에 대응해야 하므로, 만약 'CustomerID'가 'Customers' 테이블에 없는 값을 가지고 있다면 문제가 발생할 수 있습니다. 이런 문제를 방지하기 위해, 외래 키 제약 조건(foreign key constraint)을 사용하여 무결성을 보장할 수 있습니다.

 

[예제] 

ALTER TABLE Orders
ADD FOREIGN KEY (CustomerID) REFERENCES Customers(ID);


위의 SQL 쿼리는 'CustomerID'가 'Customers' 테이블의 'ID'를 참조하도록 하며, 이로써 'CustomerID'가 유효한 값만 가질 수 있도록 보장합니다. 이런 식으로 외래 키는 데이터의 일관성을 보장하며, 테이블 간의 관계를 명확하게 표현하는 강력한 도구가 됩니다.

2.3. 관계형 스키마 및 테이블

데이터베이스의 뼈대인 '스키마'와 '테이블'에 대해 배울 것입니다. 스키마는 데이터베이스의 구조를 나타내며, 테이블은 이 구조 안에서 실제 데이터가 저장되는 곳입니다. 이번 챕터에서는 스키마와 테이블이 무엇인지, 어떻게 생성하고 관리하는지에 대한 기본적인 이해를 돕기 위해, 복잡한 관계형 데이터 모델의 기본 원칙을 단순하게 풀어 설명하겠습니다. 이해를 돕기 위해 실제 예제를 통해 설명을 진행하겠습니다.

2.3.1. 스키마 및 그 구성 요소의 개념

데이터베이스에서 '스키마'란 데이터의 구조를 정의하는 방법을 말합니다. 스키마는 데이터베이스의 틀이나 테이블, 열, 데이터 타입, 관계 등을 정의하며, 이런 구조를 통해 실제 데이터가 어떻게 구성되고 저장될지를 명시합니다. 스키마는 마치 건축설계도 같은 것으로, 빌딩(데이터베이스)의 각 층(테이블)과 방(열)의 위치와 크기, 기능 등을 미리 정의해 두는 것이라고 생각하면 이해하기 쉽습니다.

 

예를 들어, 학생들의 성적을 관리하는 데이터베이스를 만든다고 가정해 봅시다. 이 데이터베이스에는 학생들의 정보를 담는 '학생' 테이블과 과목 정보를 담는 '과목' 테이블, 그리고 학생들의 성적을 담는 '성적' 테이블이 필요할 것입니다. 각 테이블의 스키마는 다음과 같이 정의할 수 있습니다.

 

'학생' 테이블 스키마

[예제] 

CREATE TABLE 학생 (
    학번 INT PRIMARY KEY,
    이름 VARCHAR(20),
    전공 VARCHAR(50)
);

 

'과목' 테이블 스키마

[예제] 

CREATE TABLE 과목 (
    과목코드 INT PRIMARY KEY,
    과목명 VARCHAR(50),
    학점 INT
);

 

'성적' 테이블 스키마

[예제] 

CREATE TABLE 성적 (
    학번 INT,
    과목코드 INT,
    성적 CHAR(1),
    PRIMARY KEY (학번, 과목코드),
    FOREIGN KEY (학번) REFERENCES 학생(학번),
    FOREIGN KEY (과목코드) REFERENCES 과목(과목코드)
);

 

위의 예시에서 '학생' 테이블은 '학번', '이름', '전공' 세 개의 열을 가지며, '학번'이 기본 키로 정의되어 있습니다. '과목' 테이블은 '과목코드', '과목명', '학점' 세 개의 열을 가지며, '과목코드'가 기본 키로 정의되어 있습니다. '성적' 테이블은 '학번'과 '과목코드', '성적' 세 개의 열을 가지며, '학번'과 '과목코드'가 합쳐진 복합키가 기본 키로 정의되어 있습니다. 또한, '성적' 테이블의 '학번' 열은 '학생' 테이블의 '학번' 열을 참조하고, '성적' 테이블의 '과목코드' 열은 '과목' 테이블의 '과목코드' 열을 참조하는 외래 키로 설정되어 있습니다. 이렇게 스키마를 통해 테이블의 구조와 테이블 간의 관계를 미리 정의해 두면, 실제 데이터를 입력하고 관리하는 데 있어서 일관성과 효율성을 보장할 수 있습니다. 

 

이렇게 테이블 간의 관계를 설정하는 것은 관계형 데이터베이스의 핵심적인 부분입니다. 외래 키를 통해 테이블 간의 관계를 설정함으로써, 한 테이블의 데이터가 다른 테이블의 데이터와 어떤 연관성을 가지는지를 명시적으로 표현할 수 있습니다. 이렇게 함으로써 데이터베이스의 무결성을 보장하고, 데이터 조작 시에도 일관성을 유지할 수 있습니다.

 

그럼 이제 SQL을 통해 '성적' 테이블에 데이터를 추가해 보겠습니다. 이 때, 학생의 학번과 과목 코드가 각각 '학생' 테이블과 '과목' 테이블에 실제로 존재하는지 확인하고, 존재하는 경우에만 데이터를 추가하도록 할 것입니다.

 

[예제] 

INSERT INTO 성적 (학번, 과목코드, 성적)
VALUES (20210001, 101, 'A');

 

위의 SQL 쿼리는 학번 20210001인 학생이 과목코드 101인 과목에서 'A'성적을 받았다는 정보를 '성적' 테이블에 추가하고 있습니다. 만약 '학생' 테이블에 학번 20210001인 학생이 존재하지 않거나, '과목' 테이블에 과목코드 101인 과목이 존재하지 않는다면, 이 쿼리는 외래 키 제약 조건에 의해 실패하게 됩니다. 

 

이처럼 스키마는 데이터베이스의 구조를 정의하고, 그 구조에 따라 데이터를 조작하는 방법을 제공합니다. SQL은 이러한 스키마를 기반으로 데이터를 조회, 추가, 수정, 삭제하는 등의 작업을 수행하는 강력한 도구입니다. 

 

관계형 데이터베이스에서는 테이블 간에 서로 다양한 관계를 설정할 수 있습니다. 이는 데이터의 효율적인 관리와 활용을 가능하게 합니다. 관계 설정의 핵심적인 방법 중 하나는 바로 '외래 키(Foreign Key)'를 이용하는 것입니다.

 

외래 키는 한 테이블의 필드가 다른 테이블의 기본 키(Primary Key)를 참조하고 있는 상황을 가리킵니다. 이 외래 키의 설정을 통해, 테이블 간에 '관계'를 형성하게 되는 것입니다.

 

예를 들어, '학생'이라는 테이블이 있고, '성적'이라는 테이블이 있다고 가정해봅시다.가정해 봅시다. '학생' 테이블의 '학번' 필드는 기본 키로 설정되어 있고, '성적' 테이블에는 학생의 성적 정보와 함께 학생의 '학번' 정보를 포함하고 있다고 가정해 봅시다. 이때, '성적' 테이블의 '학번' 필드를 '학생' 테이블의 '학번' 필드를 참조하도록 설정하면, 이 두 테이블 간에 관계를 설정할 수 있습니다.

 

즉, '성적' 테이블의 '학번' 필드는 '학생' 테이블의 '학번' 필드를 외래 키로 참조하고 있는 것이죠. 이를 통해, 학생 한 명에 대한 성적 정보를 효율적으로 관리하고 조회할 수 있게 됩니다.

 

이처럼, 관계형 데이터베이스에서는 외래 키를 통해 테이블 간에 다양한 관계를 설정하고, 이를 통해 데이터를 효율적으로 관리하고 활용할 수 있습니다.

 

스키마(schema)는 데이터베이스의 구조를 정의하는 청사진으로 생각할 수 있습니다. 데이터베이스에 어떤 테이블이 있으며, 각 테이블은 어떤 필드를 가지고 있는지, 그리고 이들 사이에 어떤 관계가 있는지를 명세하는 것, 이것이 바로 스키마의 역할입니다.

 

스키마는 크게 '물리적 스키마', '논리적 스키마', 그리고 '뷰 스키마'로 나눌 수 있습니다. 물리적 스키마는 데이터베이스의 물리적인 저장 구조를 설명합니다. 즉, 데이터가 어떻게 드라이브에 저장되는지, 인덱싱은 어떻게 이루어지는지 등의 정보를 담고 있습니다.

 

반면, 논리적 스키마는 테이블, 속성, 관계 등과 같은 데이터베이스의 논리적인 구조를 명세합니다. 즉, 사용자가 데이터베이스를 어떻게 보고 이해해야 하는지를 명시합니다. 이 논리적 스키마는 SQL을 이용하여 테이블을 생성하거나 수정하는 등의 작업을 통해 정의됩니다. 

 

뷰 스키마는 사용자에게 보여지는 데이터베이스의 모습을 설명합니다. 뷰는 기본 테이블로부터 파생된 가상의 테이블로서, 사용자에게 필요한 정보만을 제공하거나 복잡한 쿼리를 단순화하는 등의 역할을 합니다. 

 

이제 예제 코드를 통해 이해를 높여 보겠습니다. 다음은 'employees'라는 테이블을 생성하는 SQL 쿼리입니다.

 

[예제] 

CREATE TABLE employees (
    ID INT PRIMARY KEY,
    name VARCHAR(100),
    birth_date DATE,
    position VARCHAR(50),
    salary INT
);

 

이 SQL문은 'employees'라는 테이블을 생성하며, 이 테이블은 'ID', 'name', 'birth_date', 'position', 그리고 'salary'라는 5개의 필드를 가지고 있습니다. 각 필드의 데이터 타입도 함께 명시되어 있습니다. 'ID' 필드는 'INT' 타입이며, 이 필드는 테이블의 기본 키로 지정되어 있습니다.

 

이처럼 SQL을 통해 데이터베이스의 논리적 스키마를 정의하고, 이 스키마를 통해 데이터를 저장하고 관리합니다.

 

테이블은 관계형 데이터베이스에서 가장 기본이 되는 구성 요소입니다. 테이블은 행(row)과 열(column)의 2차원 구조로 데이터를 저장합니다. 각 열(column)은 특정 유형의 데이터를 나타내는 필드(field)이며, 각 행(row)은 해당 필드에 대한 데이터 레코드(record)를 나타냅니다. 각 레코드는 고유한 키에 의해 식별됩니다. 

 

다음은 'employees' 테이블에 데이터를 추가하는 SQL 쿼리입니다.

 

[예제] 

INSERT INTO employees (ID, name, birth_date, position, salary)
VALUES (1, 'John Doe', '1990-07-22', 'Software Engineer', 70000);

 

이 SQL문은 'employees' 테이블에 새로운 레코드를 추가합니다. 각 필드에 대한 값을 명시적으로 제공하고 있습니다.

 

관계형 데이터베이스에서 테이블 간의 관계는 기본 키와 외래 키를 통해 설정됩니다. 기본 키(primary key)는 테이블의 각 레코드를 고유하게 식별하는 필드입니다. 외래 키(foreign key)는 다른 테이블의 레코드를 참조하는 필드입니다.

 

예를 들어, 'employees' 테이블과 'departments' 테이블이 있을 때, 'employees' 테이블의 'department_id' 필드가 'departments' 테이블의 'id' 필드를 참조한다면, 'department_id' 필드는 외래 키가 됩니다. 

 

이런 방식으로 스키마는 데이터베이스의 구조와 관계를 정의하며, 이를 바탕으로 SQL 쿼리를 통해 데이터를 추가, 검색, 수정, 삭제하는 등의 작업을 수행할 수 있습니다.

 

2.3.2. 관계형 데이터베이스에서 테이블 생성 및 관리하기

데이터베이스에서 테이블을 생성하고 관리하는 것은 매우 중요한 작업이며, 이를 위해 SQL의 여러 문법을 사용하게 됩니다. SQL은 테이블을 생성하는 CREATE TABLE, 데이터를 추가하는 INSERT, 데이터를 조회하는 SELECT, 데이터를 수정하는 UPDATE, 그리고 데이터를 삭제하는 DELETE 등 다양한 명령어를 제공합니다.

 

예를 들어, 아래는 'employees' 테이블을 생성하는 SQL 쿼리입니다.

 

[예제] 

CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    birth_date DATE,
    position VARCHAR(50),
    salary INT
);

 

위 쿼리는 'employees'라는 이름의 테이블을 생성하고 있습니다. 각 칼럼의 이름과 데이터 타입, 그리고 'id' 칼럼을 기본 키로 설정하는 등의 작업을 수행하고 있습니다. 기본 키는 각 레코드를 유일하게 식별할 수 있도록 하는 역할을 합니다.

 

테이블이 생성된 후에는 INSERT 문을 사용해 데이터를 추가할 수 있습니다. 예를 들어, 아래 쿼리는 새로운 직원 정보를 'employees' 테이블에 추가합니다.

 

[예제] 

INSERT INTO employees (id, name, birth_date, position, salary)
VALUES (1, 'John Doe', '1990-07-22', 'Software Engineer', 70000);

 

데이터를 조회할 때는 SELECT 문을 사용합니다. 다음 쿼리는 'employees' 테이블에서 모든 직원의 정보를 조회합니다.

 

[예제] 

SELECT * FROM employees;

 

데이터를 수정하려면 UPDATE 문을 사용하며, 데이터를 삭제하려면 DELETE 문을 사용합니다. 다음은 'employees' 테이블에서 id가 1인 직원의 직위를 'Senior Software Engineer'로 변경하는 쿼리입니다.

 

[예제] 

UPDATE employees
SET position = 'Senior Software Engineer'
WHERE id = 1;

 

그리고 아래는 'employees' 테이블에서 id가 1인 직원의 정보를 삭제하는 쿼리입니다.

 

[예제] 

DELETE FROM employees WHERE id = 1;

 

이렇게 SQL을 사용하면 관계형 데이터베이스에서 테이블을 생성하고, 데이터를 추가, 조회, 수정, 삭제하는 등의 작업을 수행할 수 있습니다. 

 

테이블을 관리하는 다른 중요한 부분은 '테이블 구조 변경'입니다. 때로는 새로운 필드를 추가하거나, 기존 필드의 이름을 변경하거나, 필드를 삭제해야 할 수 있습니다. 이러한 작업들은 ALTER TABLE 명령을 사용하여 수행할 수 있습니다. 

 

예를 들어, 다음의 쿼리는 'employees' 테이블에 'department'라는 새로운 필드를 추가합니다. 

 

[예제] 

ALTER TABLE employees 
ADD department VARCHAR(50);

 

비슷하게, 필드의 이름을 변경하려면 다음과 같이 수행할 수 있습니다.

 

[예제] 

ALTER TABLE employees 
CHANGE department dept VARCHAR(50);

 

위의 쿼리는 'department' 필드의 이름을 'dept'로 변경하고 있습니다. 마지막으로, 필드를 삭제하려면 다음과 같은 쿼리를 사용합니다. 

 

[예제] 

ALTER TABLE employees 
DROP dept;

 

데이터베이스에서 테이블을 관리하는 것은 중요한 작업이며, 이를 통해 원하는 정보를 적절하게 저장하고 조회할 수 있습니다. 관계형 데이터베이스의 핵심 개념인 '테이블'에 대해 이해하고, 이를 어떻게 사용하고 관리하는지 알아보았습니다. 

인덱스는 데이터베이스에서 매우 중요한 개념입니다. 왜냐하면, 인덱스는 테이블 내의 데이터를 빠르게 검색할 수 있게 해주는 도구이기 때문입니다. 이를 이해하려면 책의 색인을 생각해 보세요. 책의 색인 없이 특정 주제를 찾는 것은 많은 시간이 걸릴 것입니다. 하지만 색인이 있으면, 해당 주제가 어디에 있는지 즉시 알 수 있습니다. 이것이 바로 인덱스가 데이터베이스에서 하는 일입니다. 

 

SQL에서, 인덱스는 CREATE INDEX 명령을 사용하여 생성할 수 있습니다. 예를 들어, 'employees' 테이블에서 'last_name' 필드에 대한 인덱스를 만들고 싶다면, 다음과 같이 작성할 수 있습니다. 

 

[예제] 

CREATE INDEX idx_lastname 
ON employees (last_name);

 

위의 쿼리는 'last_name' 필드에 대해 인덱스를 생성하고, 이 인덱스의 이름을 'idx_lastname'로 지정합니다. 이제 'last_name' 필드를 기준으로 데이터를 검색할 때, 데이터베이스는 인덱스를 사용하여 훨씬 빠르게 결과를 반환할 수 있습니다.

 

하지만 인덱스에는 장단점이 있습니다. 장점은 앞서 말했듯이, 검색 성능을 크게 향상시킬 수 있다는 점입니다. 하지만 단점은, 인덱스를 유지하기 위해 추가적인 저장 공간이 필요하다는 점과, 데이터가 변경될 때마다 인덱스도 업데이트해야 하므로, 데이터 수정(삽입, 삭제, 수정) 성능이 저하될 수 있다는 점입니다. 따라서 어떤 필드에 인덱스를 생성할지, 어떤 필드는 생략할지는 신중한 고려가 필요합니다.

 

 

 

2023.06.17 - [GD's IT Lectures : 기초부터 시리즈/데이터베이스(DB) 기초부터 ~] - [데이터베이스(DB)] 1. 데이터베이스 소개

 

[데이터베이스(DB)] 1. 데이터베이스 소개

Chapter 1. 데이터베이스 소개 데이터베이스는 정보를 저장, 검색, 업데이트, 관리하는 시스템입니다. 이러한 시스템은 우리가 개발하는 많은 애플리케이션에서 핵심적인 역할을 합니다. 이번 장

gdngy.tistory.com

 

반응형

'GD's IT Lectures : 기초부터 시리즈 > 데이터베이스(DB) 기초부터 ~' 카테고리의 다른 글

[데이터베이스(DB)] 1. 데이터베이스 소개  (0) 2023.06.17

관련글

댓글

티스토리툴바