데이터 베이스 관계의 개념과 무결성 이해하기

SEUNGJUN·2024년 6월 10일
db
0

DATABASE

목록 보기
3/4

데이터베이스에서 관계 설정은 데이터의 무결성과 효율적인 관리에 매우 중요하다. 관계를 설정한면 데이터베이스 시스템은 데이터의 일관성을 유지하고, 중복 데이터 입력을 방지며, 복잡한 쿼리를 쉽게 수행할 수 있다. 이러한 관계는 데이터베이스 설계의 핵심 요소로, 데이터를 어떻게 저장하고 검색할지에 큰 영향을 미친다.

관계 설정의 중요성

1. 데이터 무결성 유지

  • 참조 무결성 : 외래 키 제약 조건을 통해 관련된 테이블 간의 데이터 일관성을 유지할 수 있다. 예를 들어, 댓글이 존재하는 포스트가 삭제되면, 댓글도 자동으로 삭제되거나 외래 키 제약 조건으로 인해 삭제가 방지될수 있다.

  • 중복 방지: 관계를 설정하면 중복 데이터 입력을 방지할 수 있다. 예를 들어, 동일한 학생이 여러 번 등록되는 것을 방지할 수 있다.

2. 효율적인 데이터 관리

  • 복잡한 쿼리: 관계형 데이터베이스는 조인을 통해 여러 테이블의 데이터를 효율적으로 조회할수 있다. 예를 들어, 특정 블로그 포스트와 그에 대한 모든 댓글을 한 번의 쿼리로 가져올수 있다.

  • 데이터 무결성: 관계를 설정하면 데이터 베이스 시스템이 자동으로 데이터의 일관성을 유지한다. 예를 들어, 사용자가 삭제되면 해당 사용자의 프로필도 자동으로 삭제할 수 있다.

3. 성능 향상

  • 인덱스 활용 : 관계형 데이터베이스는 인덱스를 활용하여 데이터를 빠르게 조회할 수 있다. 외래 키 제약 조건은 인덱스를 사용하여 조인 연산을 최적화할 수 있다.

  • 데이터 정규화 : 관계를 설정하면 데이터를 정규화하여 데이터 중복을 최소화하고 저장 공간을 효율적으로 사용할 수 있다.

데이터베이스에서 무결성이란 데이터의 정확성, 일관성, 완전성을 보장하는 것을 의미한다. 무결성은 데이터베이스 관리 시스템(DBMS)이 데이터의 신뢰성을 유지하고 데이터의 손상이나 오류를 방지하기 위해 중요한 개념이다.

데이터 베이스 무결성의 주요 유형

1. 도메인 무결성 (Domain Integrity)

  • 도메인 무결성은 각 열(column)에 저장될 수 있는 값의 범위를 정의하는 제약 조건이다. 예를 들어, 나이(age) 열은 0 이상이어야 하고, 이메일(email) 열은 특정 형식을 따라야 한다. 이러한 제약 조건을 통해 잘못된 데이터 입력을 방지한다.
CREATE TABLE User (
    id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    age INT CHECK (age >= 0)
);

2. 엔티티 무결성 (Entity Integrity)

  • 엔티티 무결성은 테이블의 각 행(row)이 고유하게 식별될 수 있도록 보장하는 제약 조건이다. 일반적으로 기본 키(Primary Key)를 통해 이루어진다. 기본 키는 중복될 수 없고, NULL 값을 가질 수 없다.
CREATE TABLE User (
    id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);

3. 참조 무결성 (Referential Integrity)

  • 참조 무결성은 테이블 간의 관계를 유지하는 제약 조건이다. 외래 키(Foreign Key)를 통해 한 테이블의 값이 다른 테이블의 값을 참조할 수 있게 하여, 관련된 데이터가 일관되게 유지되도록 한다. 예를 들어, 주문(order) 테이블의 사용자 ID가 사용자(user) 테이블의 ID와 일치 해야한다.
CREATE TABLE User (
    id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);

CREATE TABLE Order (
    id INT PRIMARY KEY,
    user_id INT,
    order_date DATE,
    FOREIGN KEY (user_id) REFERENCES User(id)
);

4. 고유 무결성 (Unique Integrity)

  • 고유 무결성은 특정 열이나 열의 조합에 중복된 값이 없도록 하는 제약 조건이다. UNIQUE 제약 조건을 사용하여 중복 데이터를 방지한다.
CREATE TABLE User (
    id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) UNIQUE
);

5. 관계 무결성 (Relational Integrity)

  • 관계 무결성은 데이터베이스 내의 여러 테이블 간의 논리적 관계를 유지하는 제약 조건이다. 일반적으로 여러 무결성 제약 조건을 함께 사용하여 전체 데이터베이스의 일관성을 보장한다.

무결성의 중요성

1. 데이터 정확성 보장

  • 잘못된 데이터 입력을 방지하여 데이터의 정확성을 유지한다.

2. 데이터 일관성 유지

  • 여러 테이블 간의 데이터가 일관되게 유지한다.

3. 데이터 신뢰성 향상

  • 사용자가 데이터를 신뢰할 수 있게 하여 데이터베이스의 신뢰성을 높인다.

4. 데이터 중복 방지

  • 중복 데이터를 방지하여 저장 공간을 효율적으로 사용하고 데이터 관리의 복잡성을 줄인다.

데이터 베이스 관계

1. 일대일(One-to-One) 관계

개념

  • 하나의 레코드가 다른 테이블의 하나의 레코드와 연결된 경우

EX) 사용자 테이블과 사용자 프로필 테이블

  • 각 사용자는 하나의 프로필만 가질 수 있고, 각 프로필은 하나의 사용자에게만 속한다.

  • 시각화: 사용자(User) <-> 사용자 프로필(Profile)

테이블 구조

CREATE TABLE User (
    id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);

CREATE TABLE UserProfile (
    user_id INT PRIMARY KEY,
    bio TEXT,
    FOREIGN KEY (user_id) REFERENCES User(id)
);

PK와 FK 위치

  • 단일 테이블: 두 테이블 중 하나의 기본 키를 다른 테이블의 외래 키로 사용한다. 보통 두 테이블 중 어느 한 테이블의 기본(PK)를 다른 테이블에 외래 키(FK)로 포함시키면 된다.

2. 일대다(One-to-Many) 관계

개념

  • 하나의 레코드가 다른 테이블의 여러 레코드와 연결된 경우

EX) 블로그 포스트와 댓글

  • 각 블로그 포스트는 여러 댓글을 가질 수 있지만, 각 댓글은 하나의 포스트에만 속한다.

  • 시각화: 블로그 포스트(Post) <->(Comment)

테이블 구조

CREATE TABLE BlogPost (
    id INT PRIMARY KEY,
    title VARCHAR(100),
    content TEXT
);

CREATE TABLE Comment (
    id INT PRIMARY KEY,
    post_id INT,
    comment TEXT,
    FOREIGN KEY (post_id) REFERENCES BlogPost(id)
);

  • PK와 FK 위치

  • 다 쪽 테이블: 다 쪽 테이블에 외래 키(FK)가 포함된다. 1쪽 테이블의 기본 키(PK)가 N쪽 테이블의 외래 키(FK)가 된다.

3. 다대다(Many-to-Many) 관계

개념

  • 여러 레코드가 다른 테이블의 여러 레코드와 연결된 경우

EX) 학생과 수업

  • 각 학생은 여러 수업을 들을 수 있고, 각 수업에는 여러 학생이 참여할 수 있다.

  • 시각화: 학생(Student) <-> 수업(Class)

테이블 구조

CREATE TABLE Student (
    id INT PRIMARY KEY,
    name VARCHAR(50)
);

CREATE TABLE Class (
    id INT PRIMARY KEY,
    title VARCHAR(100)
);

CREATE TABLE StudentClass (
    student_id INT,
    class_id INT,
    PRIMARY KEY (student_id, class_id),
    FOREIGN KEY (student_id) REFERENCES Student(id),
    FOREIGN KEY (class_id) REFERENCES Class(id)
);

  • PK와 FK 위치

  • 중간 테이블: 두 테이블 사이에 중간 테이블(조인 테이블)을 만들어 두 테이블의 기본 키(PK)를 중간 테이블의 외래 키(FK)로 포함시킨다. 중간 테이블은 보통 두 외래 키를 복합 키로 사용한다.

NestJS에서 관계 사용하기

1. 일대일 관계

// user.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn } from 'typeorm';
import { UserProfile } from './userProfile.entity';

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    username: string;

    @OneToOne(() => UserProfile)
    @JoinColumn()
    profile: UserProfile;
}

// userProfile.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, OneToOne } from 'typeorm';
import { User } from './user.entity';

@Entity()
export class UserProfile {
    @PrimaryGeneratedColumn()
    user_id: number;

    @Column()
    bio: string;

    @OneToOne(() => User)
    user: User;
}

2. 일대다 관계

// blogPost.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
import { Comment } from './comment.entity';

@Entity()
export class BlogPost {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    title: string;

    @Column()
    content: string;

    @OneToMany(() => Comment, comment => comment.post)
    comments: Comment[];
}

// comment.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
import { BlogPost } from './blogPost.entity';

@Entity()
export class Comment {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    comment: string;

    @ManyToOne(() => BlogPost, post => post.comments)
    post: BlogPost;
}

3. 다대다 관계

// student.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable } from 'typeorm';
import { Class } from './class.entity';

@Entity()
export class Student {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @ManyToMany(() => Class, classEntity => classEntity.students)
    @JoinTable()
    classes: Class[];
}

// class.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from 'typeorm';
import { Student } from './student.entity';

@Entity()
export class Class {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    title: string;

    @ManyToMany(() => Student, student => student.classes)
    students: Student[];
}
profile
SEUNGJUN
RECORD DEVELOPER
이전 포스트

DAO와 ORM 이해하기

다음 포스트

데이터 베이스 Join 이해하기

0개의 댓글