Какие ограничения создает внешний ключ

Ограничения, создаваемые внешним ключом

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

Основное определение

-- Определение таблицы с внешним ключом
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL,
    order_date TIMESTAMP NOT NULL,
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id)
);

Главные ограничения внешнего ключа

1. Ограничение на вставку данных (INSERT)

-- Таблица customers
INSERT INTO customers (id, name) VALUES ('uuid-1', 'John Doe');

-- Попытка вставить заказ с несуществующим customer_id
INSERT INTO orders (id, customer_id, order_date) 
VALUES ('order-1', 'non-existent-uuid', '2024-03-22');
-- ОШИБКА: violates foreign key constraint

-- Правильно: customer_id должен существовать в customers
INSERT INTO orders (id, customer_id, order_date) 
VALUES ('order-1', 'uuid-1', '2024-03-22');
-- OK

Ограничение: Можно вставить данные в дочернюю таблицу только если соответствующая строка уже существует в родительской таблице.

2. Ограничение на обновление данных (UPDATE)

-- Попытка обновить customer_id на несуществующий
UPDATE orders 
SET customer_id = 'non-existent-uuid' 
WHERE id = 'order-1';
-- ОШИБКА: violates foreign key constraint

-- Правильно
UPDATE orders 
SET customer_id = 'uuid-2' 
WHERE id = 'order-1';
-- OK (если uuid-2 существует)

Ограничение: При обновлении дочерней таблицы внешний ключ должен ссылаться на существующую строку в родительской таблице.

3. Ограничение на удаление данных (DELETE)

Это создаёт разные сценарии в зависимости от конфигурации:

3.1 RESTRICT (по умолчанию) — запретить удаление

CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL,
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE RESTRICT  -- Явно указываем
);

-- Попытка удалить customer с заказами
DELETE FROM customers WHERE id = 'uuid-1';
-- ОШИБКА: violates foreign key constraint
-- Сначала нужно удалить заказы или обновить их customer_id

DELETE FROM orders WHERE customer_id = 'uuid-1';
DELETE FROM customers WHERE id = 'uuid-1';
-- OK

3.2 CASCADE — удалить зависимые данные

CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL,
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE CASCADE  -- Автоматически удалить
);

-- Удаление customer
DELETE FROM customers WHERE id = 'uuid-1';
-- Все заказы этого customer АВТОМАТИЧЕСКИ удалятся
-- Результат: customer и все его заказы удалены

Внимание: CASCADE опасен, может привести к неожиданному удалению больших объёмов данных.

3.3 SET NULL — установить NULL

CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID,  -- Может быть NULL
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE SET NULL  -- Установить NULL при удалении
);

-- Удаление customer
DELETE FROM customers WHERE id = 'uuid-1';
-- customer_id в заказах этого customer станет NULL

3.4 SET DEFAULT — установить значение по умолчанию

CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID DEFAULT 'default-customer-uuid',
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE SET DEFAULT
);

4. Ограничение на обновление родительского ключа

-- Попытка обновить PRIMARY KEY в customers
UPDATE customers SET id = 'new-uuid' WHERE id = 'uuid-1';
-- ОШИБКА: если есть orders, ссылающиеся на этого customer

-- Этого можно избежать с ON UPDATE CASCADE
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL,
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON UPDATE CASCADE
);

-- Теперь при обновлении customer.id
-- все orders.customer_id обновятся автоматически
UPDATE customers SET id = 'new-uuid' WHERE id = 'uuid-1';
-- customer_id в заказах автоматически обновится

Реальный пример: заказы с товарами

-- Таблица customers
CREATE TABLE customers (
    id UUID PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL
);

-- Таблица orders
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL,
    created_at TIMESTAMP NOT NULL,
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE CASCADE  -- При удалении customer удалятся его заказы
);

-- Таблица order_items
CREATE TABLE order_items (
    id UUID PRIMARY KEY,
    order_id UUID NOT NULL,
    product_id UUID NOT NULL,
    quantity INT NOT NULL,
    CONSTRAINT fk_order_items_order 
        FOREIGN KEY (order_id) 
        REFERENCES orders(id) 
        ON DELETE CASCADE  -- При удалении заказа удалятся его товары
);

-- Таблица products
CREATE TABLE products (
    id UUID PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    price DECIMAL(10, 2) NOT NULL
);

-- Когда вы удалите customer, произойдёт каскадное удаление:
-- 1. Удалятся все orders этого customer
-- 2. Удалятся все order_items этих orders

Правила для внешних ключей в Java/JPA

@Entity
@Table(name = "customers")
public class Customer {
    @Id
    private UUID id;
    
    private String email;
    
    // Каскадное удаление
    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Order> orders = new ArrayList<>();
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    private UUID id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id", nullable = false)
    private Customer customer;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();
}

@Entity
@Table(name = "order_items")
public class OrderItem {
    @Id
    private UUID id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id", nullable = false)
    private Order order;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "product_id", nullable = false)
    private Product product;
}

Проблемы и как их избежать

Проблема 1: Циклические внешние ключи

-- ПРОБЛЕМА: A -> B -> A
CREATE TABLE A (
    id UUID PRIMARY KEY,
    b_id UUID REFERENCES B(id)
);

CREATE TABLE B (
    id UUID PRIMARY KEY,
    a_id UUID REFERENCES A(id)
);

-- Решение: используй отложенные проверки или переработай схему

Проблема 2: Каскадное удаление слишком агрессивно

-- ПРОБЛЕМА
CREATE TABLE products (
    id UUID PRIMARY KEY,
    category_id UUID NOT NULL,
    CONSTRAINT fk_products_category 
        FOREIGN KEY (category_id) 
        REFERENCES categories(id) 
        ON DELETE CASCADE  -- Удалит все продукты категории!
);

-- Решение: используй ON DELETE RESTRICT
CREATE TABLE products (
    id UUID PRIMARY KEY,
    category_id UUID NOT NULL,
    CONSTRAINT fk_products_category 
        FOREIGN KEY (category_id) 
        REFERENCES categories(id) 
        ON DELETE RESTRICT  -- Запрети удаление, если есть продукты
);

Проблема 3: NULL в не-nullable колонке

-- ПРОБЛЕМА
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID,  -- Может быть NULL
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE SET NULL  -- Станет NULL
);
-- Это может привести к потере данных

-- Решение: сделай обязательным
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL,  -- Никогда не NULL
    CONSTRAINT fk_orders_customer 
        FOREIGN KEY (customer_id) 
        REFERENCES customers(id) 
        ON DELETE CASCADE
);

Чек-лист при проектировании внешних ключей

1. Определи стратегию удаления

   • RESTRICT — для критичных данных
   • CASCADE — только если уверен
   • SET NULL — только для опциональных связей

2. Сделай внешний ключ NOT NULL если связь обязательна

3. Используй правильные типы данных

   • UUID для уникальности
   • Одинаковый тип в обеих таблицах

4. Индексируй внешние ключи

   CREATE INDEX idx_orders_customer_id ON orders(customer_id);
   

5. Тестируй граничные случаи

   • Удаление родительской записи
   • Обновление внешнего ключа
   • Вставка несуществующей ссылки

Внешние ключи — это фундамент целостности данных в реляционных базах. Правильное их использование предотвращает множество ошибок в production'е.