Какие знаешь типы связи между таблицами в базе данных?

# Типы связей между таблицами в БД

Введение

Связи между таблицами определяют структуру реляционной БД и позволяют избежать дублирования данных. Существует 4 основных типа отношений.

1. One-to-One (1:1) - Один к одному

Каждой записи в таблице A соответствует ровно одна запись в таблице B, и наоборот.

-- Пример: Пользователь и его профиль
CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    email VARCHAR(255) NOT NULL UNIQUE
);

CREATE TABLE profiles (
    id BIGINT PRIMARY KEY,
    user_id BIGINT NOT NULL UNIQUE,
    bio TEXT,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

@Entity
public class User {
    @Id
    private Long id;
    private String email;
    
    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private Profile profile;
}

@Entity
public class Profile {
    @Id
    private Long id;
    private String bio;
    
    @OneToOne
    @JoinColumn(name = "user_id", unique = true)
    private User user;
}

Когда использовать:

• Разделение логики (основные данные и расширенные)
• Опциональные данные (не все пользователи заполняют профиль)
• Разделение доступа (профиль более конфиденциален)

2. One-to-Many (1:N) - Один ко многим

Одной записи в таблице A соответствует несколько записей в таблице B.

-- Пример: Пользователь и его заказы
CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    name VARCHAR(255)
);

CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    total_amount DECIMAL(10,2),
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders = new ArrayList<>();
}

@Entity
public class Order {
    @Id
    private Long id;
    private BigDecimal totalAmount;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
}

Когда использовать:

• Наиболее часто встречающаяся связь
• Иерархичные структуры (родитель-дети)

3. Many-to-One (N:1) - Много к одному

Обратная сторона One-to-Many. Несколько записей в таблице A ссылаются на одну запись в таблице B.

-- Пример: Комментарии к посту
CREATE TABLE posts (
    id BIGINT PRIMARY KEY,
    title VARCHAR(255)
);

CREATE TABLE comments (
    id BIGINT PRIMARY KEY,
    post_id BIGINT NOT NULL,
    content TEXT,
    FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE
);

@Entity
public class Post {
    @Id
    private Long id;
    private String title;
    
    @OneToMany(mappedBy = "post")
    private List<Comment> comments;
}

@Entity
public class Comment {
    @Id
    private Long id;
    private String content;
    
    @ManyToOne
    @JoinColumn(name = "post_id")
    private Post post;
}

4. Many-to-Many (N:M) - Много ко многим

Несколько записей в таблице A соответствуют нескольким записям в таблице B.

-- Пример: Студенты и курсы
CREATE TABLE students (
    id BIGINT PRIMARY KEY,
    name VARCHAR(255)
);

CREATE TABLE courses (
    id BIGINT PRIMARY KEY,
    title VARCHAR(255)
);

-- Таблица связи
CREATE TABLE student_courses (
    student_id BIGINT NOT NULL,
    course_id BIGINT NOT NULL,
    enrolled_date TIMESTAMP,
    PRIMARY KEY (student_id, course_id),
    FOREIGN KEY (student_id) REFERENCES students(id) ON DELETE CASCADE,
    FOREIGN KEY (course_id) REFERENCES courses(id) ON DELETE CASCADE
);

@Entity
public class Student {
    @Id
    private Long id;
    private String name;
    
    @ManyToMany
    @JoinTable(
        name = "student_courses",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses = new ArrayList<>();
}

@Entity
public class Course {
    @Id
    private Long id;
    private String title;
    
    @ManyToMany(mappedBy = "courses")
    private List<Student> students = new ArrayList<>();
}

Сравнительная таблица

Проблема N+1 в связях

При загрузке связанных данных можно случайно сделать много запросов:

// ❌ Плохо - 1 запрос + N запросов для заказов
List<User> users = userRepository.findAll();
for (User user : users) {
    List<Order> orders = user.getOrders();  // N запросов!
}

// ✓ Хорошо - JOIN FETCH
@Query("SELECT DISTINCT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();

// или
@EntityGraph(attributePaths = "orders")
List<User> findAll();

ForeignKey типы каскадного удаления

-- ON DELETE CASCADE - удалить связанные записи
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE

-- ON DELETE SET NULL - установить NULL
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE SET NULL

-- ON DELETE RESTRICT - запретить удаление если есть связи
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE RESTRICT

@ManyToOne
@JoinColumn(name = "user_id")
private User user;  // По умолчанию RESTRICT

@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "user_id")
private User user;  // CASCADE

Рекомендации

1. Всегда используй FOREIGN KEY для целостности данных
2. Избегай циклических зависимостей в схеме
3. Используй JOIN FETCH или @EntityGraph для избежания N+1
4. Для Many-to-Many с дополнительными атрибутами создай явную entity для таблицы связи
5. Выбирай правильный тип каскадирования (обычно PERSIST и REMOVE, редко ALL)

Заключение

Правильное проектирование связей между таблицами — фундамент хорошей реляционной БД. Выбор правильного типа связи, индексы на внешних ключах и оптимизация загрузки (JOIN FETCH) критичны для производительности системы.