Как удалить клиента, связанного с другой таблицей через Foreign Key

Удаление записей с Foreign Key ограничениями

Это частая проблема в реальных приложениях. Когда удаляем клиента, возникает вопрос: что делать с заказами, которые на него ссылаются? Рассмотрим все подходы.

1. Ошибка: попытка удалить напрямую

Попытка удалить клиента, на которого ссылаются заказы:

@Service
public class CustomerService {
    @Autowired
    private CustomerRepository customerRepository;
    
    public void deleteCustomer(UUID customerId) {
        // ❌ Это выбросит исключение!
        // org.hibernate.exception.ConstraintViolationException
        customerRepository.deleteById(customerId);
    }
}

// Причина: в БД есть строки в таблице orders с foreign key на этого customer
SELECT * FROM orders WHERE customer_id = ...; // Есть результаты

2. Правильное решение: каскадное удаление ON DELETE CASCADE

Вариант А: На уровне БД миграции

-- Миграция: правильное определение FK
CREATE TABLE customers (
    id UUID PRIMARY KEY,
    name VARCHAR(255),
    email VARCHAR(255)
);

CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL,
    total DECIMAL(10, 2),
    -- Указываем ON DELETE CASCADE
    FOREIGN KEY (customer_id) 
    REFERENCES customers(id) 
    ON DELETE CASCADE
);

Вариант Б: В JPA/Hibernate сущностях

@Entity
@Table(name = "customers")
public class Customer {
    @Id
    private UUID id;
    
    private String name;
    private String email;
    
    @OneToMany(mappedBy = "customer", cascade = CascadeType.REMOVE)
    private List<Order> orders = new ArrayList<>();
    
    // getters/setters
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    private UUID id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id", nullable = false,
                foreignKey = @ForeignKey(name = "fk_order_customer",
                                        value = ConstraintMode.CONSTRAINT))
    private Customer customer;
    
    private BigDecimal total;
    
    // getters/setters
}

@Service
@Transactional
public class CustomerService {
    @Autowired
    private CustomerRepository customerRepository;
    
    public void deleteCustomer(UUID customerId) {
        // Благодаря cascade = CascadeType.REMOVE,
        // удалятся также все связанные заказы
        customerRepository.deleteById(customerId);
    }
}

Как это работает:

1. Hibernateзагружает Customer вместе с его Orders
2. Удаляет все Orders
3. Удаляет Customer
4. Все операции — одна транзакция

3. Альтернатива: мягкое удаление (Soft Delete)

Вместо физического удаления помечаем как удалённый:

@Entity
@Table(name = "customers")
public class Customer {
    @Id
    private UUID id;
    
    private String name;
    private String email;
    
    // Флаг удаления
    @Column(name = "deleted_at")
    private LocalDateTime deletedAt;
    
    public void softDelete() {
        this.deletedAt = LocalDateTime.now(ZoneId.of("UTC"));
    }
    
    public boolean isDeleted() {
        return deletedAt != null;
    }
    
    @OneToMany(mappedBy = "customer")
    private List<Order> orders = new ArrayList<>();
}

@Repository
public interface CustomerRepository extends JpaRepository<Customer, UUID> {
    // Найти только активных клиентов
    @Query("SELECT c FROM Customer c WHERE c.deletedAt IS NULL")
    List<Customer> findAllActive();
    
    @Query("SELECT c FROM Customer c WHERE c.id = :id AND c.deletedAt IS NULL")
    Optional<Customer> findByIdActive(@Param("id") UUID id);
}

@Service
@Transactional
public class CustomerService {
    @Autowired
    private CustomerRepository customerRepository;
    
    public void deleteCustomer(UUID customerId) {
        Customer customer = customerRepository.findById(customerId)
            .orElseThrow(() -> new CustomerNotFoundException());
        
        // Мягкое удаление
        customer.softDelete();
        customerRepository.save(customer);
        
        // Все заказы остаются — они просто связаны с удалённым клиентом
    }
}

Плюсы soft delete:

• История остаётся в БД
• Легко восстановить
• Нет сложных каскадов
• Аудит удаления встроен

Минусы:

• Усложняет все запросы (везде нужна проверка deletedAt)
• Требует много памяти
• Возможны ошибки (забыли где-то добавить условие)

4. Комбинированный подход: Cascade + Orphan Removal

Для сложных структур с вложенными сущностями:

@Entity
@Table(name = "customers")
public class Customer {
    @Id
    private UUID id;
    
    private String name;
    
    // cascade = CascadeType.REMOVE — удаляет заказы
    // orphanRemoval = true — удаляет заказы, если их удалили из списка
    @OneToMany(mappedBy = "customer", 
               cascade = CascadeType.REMOVE,
               orphanRemoval = true)
    private List<Order> orders = new ArrayList<>();
    
    public void removeOrder(Order order) {
        orders.remove(order);
        order.setCustomer(null);
        // thanks to orphanRemoval, order будет удалён
    }
}

@Service
@Transactional
public class OrderService {
    @Autowired
    private CustomerRepository customerRepository;
    
    public void removeOrder(UUID customerId, UUID orderId) {
        Customer customer = customerRepository.findById(customerId)
            .orElseThrow();
        
        Order orderToRemove = customer.getOrders()
            .stream()
            .filter(o -> o.getId().equals(orderId))
            .findFirst()
            .orElseThrow();
        
        // Благодаря orphanRemoval, заказ будет удалён из БД
        customer.removeOrder(orderToRemove);
        customerRepository.save(customer);
    }
}

5. Native запрос для сложных случаев

Когда ORM не справляется, пишем SQL напрямую:

@Service
@Transactional
public class CustomerService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public void deleteCustomerAndOrders(UUID customerId) {
        // Удаляем заказы
        jdbcTemplate.update(
            "DELETE FROM orders WHERE customer_id = ?",
            customerId
        );
        
        // Удаляем клиента
        jdbcTemplate.update(
            "DELETE FROM customers WHERE id = ?",
            customerId
        );
    }
}

6. Сценарии использования

Используй Cascade если:

• Данные действительно зависимые (заказы = часть клиента)
• Нет необходимости в истории
• Иерархия чёткая (родитель → дети)

Используй Soft Delete если:

• Нужна история всех изменений
• Могут быть запросы типа "найти удалённых клиентов"
• Нужна возможность восстановления
• Есть законодательные требования (GDPR)

Используй Manual Delete если:

• Сложная логика (уведомления, очистка других таблиц)
• Нужны интеграции с внешними системами
• Транзакция должна быть явной

Проверка Foreign Key перед удалением

@Service
public class CustomerService {
    @Autowired
    private CustomerRepository customerRepository;
    
    @Autowired
    private OrderRepository orderRepository;
    
    public void deleteCustomerIfPossible(UUID customerId) {
        Customer customer = customerRepository.findById(customerId)
            .orElseThrow();
        
        // Проверяем, есть ли зависимые заказы
        List<Order> orders = orderRepository.findByCustomerId(customerId);
        
        if (!orders.isEmpty()) {
            // Опция 1: выбросить ошибку
            throw new CustomerHasOrdersException(
                "Customer has " + orders.size() + " active orders"
            );
            
            // Опция 2: удалить зависимости
            // orderRepository.deleteAll(orders);
        }
        
        customerRepository.deleteById(customerId);
    }
}

Итоговая рекомендация

1. Всегда определяй FK в миграциях с явными действиями
2. На уровне JPA используй cascade = CascadeType.REMOVE или orphanRemoval
3. Для бизнес-логики — явная проверка перед удалением
4. Рассмотри Soft Delete если нужна история
5. Используй @Transactional для целостности операции