Что ограничивает Foreign Key

Foreign Key: ограничения и как они работают

Foreign Key (внешний ключ) — это один из самых мощных и, одновременно, наиболее неправильно применяемых механизмов в реляционных БД. Давайте разберёмся, что именно ограничивает Foreign Key и почему это критично для Java разработчиков.

Определение Foreign Key

Foreign Key — это механизм обеспечения referential integrity (ссылочной целостности). Он гарантирует, что значение в одной таблице ссылается только на существующие значения в другой таблице.

CREATE TABLE customers (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

CREATE TABLE orders (
    id INT PRIMARY KEY,
    customer_id INT NOT NULL,
    amount DECIMAL(10,2),
    FOREIGN KEY (customer_id) REFERENCES customers(id)
);

Эта конструкция говорит БД: "каждый customer_id в таблице orders должен существовать как id в таблице customers".

Что именно ограничивает Foreign Key

1. Ограничение INSERT в дочернюю таблицу

Вы не можете вставить заказ с несуществующим customer_id:

-- OK
INSERT INTO customers VALUES (1, 'John');
INSERT INTO orders VALUES (100, 1, 99.99);  -- customer_id 1 существует

-- ERROR
INSERT INTO orders VALUES (101, 999, 50.00);  
-- FOREIGN KEY constraint failed: customer_id 999 не существует

В контексте Java приложения это означает:

@Entity
public class Order {
    @Id private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id", nullable = false)
    private Customer customer;  // customer должен существовать
}

public void createOrder(Order order) {
    // Если customer не существует в БД — Hibernate выбросит ConstraintViolationException
    orderRepository.save(order);
}

2. Ограничение UPDATE родительской таблицы

Вы не можете изменить PRIMARY KEY родителя, если на него ссылаются дочерние записи:

-- Есть заказ с customer_id = 1
UPDATE customers SET id = 999 WHERE id = 1;
-- ERROR: FOREIGN KEY constraint failed
-- Почему? Потому что заказы ещё ссылаются на customer_id = 1

3. Ограничение DELETE из родительской таблицы

Вы не можете удалить строку из родительской таблицы, если на неё есть ссылки:

DELETE FROM customers WHERE id = 1;
-- ERROR: FOREIGN KEY constraint failed
-- Есть заказы, которые ссылаются на этого customer'а

Ограничения Foreign Key: как управлять DELETE

По умолчанию FK не позволяет удалить родителя. Но можно определить действие с помощью ON DELETE и ON UPDATE clauses:

ON DELETE RESTRICT (по умолчанию)

CREATE TABLE orders (
    id INT,
    customer_id INT,
    FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE RESTRICT  -- нельзя удалить customer, если есть orders
);

DELETE FROM customers WHERE id = 1;
-- ERROR: Cannot delete, orders still reference this customer

ON DELETE CASCADE (удалить всех детей)

CREATE TABLE orders (
    id INT,
    customer_id INT,
    FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE CASCADE  -- удалить все orders этого customer'а
);

DELETE FROM customers WHERE id = 1;
-- OK, удалятся также все orders этого customer'а

В Hibernate это выглядит так:

@Entity
public class Customer {
    @Id private Long id;
    
    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL)
    private List<Order> orders;  // при удалении customer удалятся orders
}

ON DELETE SET NULL (установить NULL)

FOREIGN KEY (customer_id) 
    REFERENCES customers(id) 
    ON DELETE SET NULL  -- заказ остаётся, но customer_id = NULL

В практике это используется редко, потому что обычно customer должен быть.

ON DELETE NO ACTION (то же, что RESTRICT)

FOREIGN KEY (...) ON DELETE NO ACTION
-- Просто запрещает удаление

Ограничения Foreign Key в контексте Java

Проблема 1: ConstraintViolationException

// Если нарушить FK constraint, получишь исключение
try {
    Order order = new Order();
    order.setCustomerId(999);  // customer не существует
    orderRepository.save(order);
} catch (DataIntegrityViolationException e) {
    // FOREIGN KEY constraint failed
    logger.error("Cannot save order: customer doesn't exist");
}

Проблема 2: Orphan deletion

Если настроить orphanRemoval = true, Hibernate удалит orders, для которых customer_id = NULL:

@OneToMany(mappedBy = "customer", orphanRemoval = true)
private List<Order> orders;

// Если сделать это:
Customer customer = customerRepository.findById(1);
customer.setOrders(new ArrayList<>());  // очистить список
customerRepository.save(customer);
// Все orders этого customer'а будут удалены из БД!

Проблема 3: Performance impact

FK проверки имеют оверхед:

• При каждом INSERT/UPDATE/DELETE БД проверяет constraint
• Это требует дополнительный index на referenced column
• Может быть bottleneck при huge batch operations

// Вставка 1M заказов с FK проверками может быть медленнее
for (int i = 0; i < 1_000_000; i++) {
    Order order = new Order();
    order.setCustomerId(customerId);  // при каждом save() — FK проверка
    orderRepository.save(order);
}

// Лучше отключить FK временно:
// SET CONSTRAINTS ALL DEFERRED;  (PostgreSQL)
// SET foreign_key_checks = 0;    (MySQL)

Типы Foreign Key constraints

One-to-Many (самый частый)

Customers (1) ←→ (Many) Orders

Один customer может иметь много orders.
Foreign Key в Orders ссылается на PRIMARY KEY в Customers.

@Entity
public class Customer {
    @Id private Long id;
    
    @OneToMany(mappedBy = "customer")
    private List<Order> orders;
}

@Entity
public class Order {
    @Id private Long id;
    
    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;
}

Many-to-One (обратная сторона)

Определяется на стороне, у которой есть Foreign Key.
Это то же One-to-Many, но с другой стороны.

Many-to-Many (через junction table)

Students ←→ (junction) Enrollments ←→ Courses

Юнкшн таблица имеет ДВУХ foreign keys:
- один на Students
- один на Courses

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

Когда отключать Foreign Key

Сценарий 1: Миграция данных

// Когда мигрируешь старые данные, может быть inconsistency
public void migrateData() {
    // Отключаем FK проверки
    jdbcTemplate.execute("SET foreign_key_checks = 0");  // MySQL
    
    try {
        // Вставляем данные (может быть temporary inconsistency)
        migrateOrders();
        migrateCustomers();
    } finally {
        // Включаем FK проверки
        jdbcTemplate.execute("SET foreign_key_checks = 1");
        
        // Проверяем целостность
        List<String> violations = findForeignKeyViolations();
        if (!violations.isEmpty()) {
            throw new MigrationException("FK violations found");
        }
    }
}

Сценарий 2: Большие batch операции

@Service
public class BulkImportService {
    
    public void importLargeDataset(List<Order> orders) {
        // Для миллионов заказов FK проверки могут быть bottleneck
        Connection conn = getConnection();
        
        // MySQL
        conn.createStatement().execute("SET foreign_key_checks = 0");
        
        try {
            // Batch insert
            for (Order order : orders) {
                insertOrder(order);
            }
            conn.commit();
        } finally {
            conn.createStatement().execute("SET foreign_key_checks = 1");
            
            // ВАЖНО: проверить целостность после
            validateIntegrity();
        }
    }
}

Сценарий 3: Архивирование и очистка

public void archiveOldData() {
    // Архивируем старые заказы
    List<Order> oldOrders = findOrdersBefore(LocalDate.now().minusYears(5));
    
    // Скопируем в архив таблицу
    copyToArchive(oldOrders);
    
    // Теперь удалим из production (может быть FOREIGN KEY constraint)
    oldOrders.forEach(order -> orderRepository.delete(order));
}

Best Practices с Foreign Keys

1. Всегда определяй ON DELETE/UPDATE

@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
private List<Order> orders;  // При удалении customer — удалятся orders

2. Используй NOT NULL для важных ссылок

CREATE TABLE orders (
    customer_id INT NOT NULL,  -- customer обязателен
    FOREIGN KEY (customer_id) REFERENCES customers(id)
);

3. Индексируй Foreign Keys

CREATE INDEX idx_order_customer ON orders(customer_id);
-- Это поможет при поиске всех заказов customer'а

4. Избегай циклических FK

-- BAD
A.id ← B.a_id
B.id ← A.b_id
-- Это может привести к deadlocks

5. Используй natural/surrogate keys правильно

-- GOOD: surrogate key
CREATE TABLE customers (
    id BIGINT PRIMARY KEY,  -- synthetic
    email VARCHAR(100) UNIQUE
);

-- REFERENCES с BIGINT FK — быстро
CREATE TABLE orders (
    customer_id BIGINT,
    FOREIGN KEY (customer_id) REFERENCES customers(id)
);

Заключение

Foreign Key ограничивает:

1. INSERT — дочерние записи должны ссылаться на существующего родителя
2. DELETE — нельзя удалить родителя, пока есть ссылки
3. UPDATE — нельзя изменить PRIMARY KEY родителя с ссылками

Для Java разработчика это означает:

• Всегда проверяй, что referenced объект существует перед сохранением
• Правильно настраивай cascade и orphanRemoval
• Понимай, как Hibernate справляется с FK
• Знай, когда отключить FK для миграций (и как их проверить)

FK — это не просто техническая деталь, это гарантия целостности данных, которая спасает миллионы в production'е.