Какие знаешь ограничения по добавлению при наличии Primary Key?

Ограничения по добавлению при наличии Primary Key

Primary Key (первичный ключ) — это уникальный идентификатор каждой записи в таблице. Его наличие накладывает серьезные ограничения на операции добавления (INSERT) данных, которые необходимо учитывать при проектировании приложения.

Ограничение уникальности

Основное ограничение Primary Key — уникальность значения. Нельзя добавить две записи с одинаковым значением primary key:

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;  // Primary Key
    
    private String email;
}

// Правильно: новый пользователь
User user1 = new User();
user1.setEmail("alice@example.com");
session.save(user1);  // id = 1

// Ошибка: попытка добавить с существующим id
User user2 = new User();
user2.setId(1L);  // Уже существует!
user2.setEmail("bob@example.com");
session.save(user2);  // Будет ошибка: PRIMARY KEY constraint failed

Невозможность добавления NULL в Primary Key

Второе ограничение — NOT NULL. В Primary Key не может быть NULL значений:

@Entity
public class Product {
    @Id
    private String sku;  // НЕ может быть NULL
    
    private String name;
}

// Ошибка: NULL в primary key
Product product = new Product();
product.setSku(null);  // Ошибка!
product.setName("Laptop");
session.save(product);

Even with @GeneratedValue, если ты вручную устанавливаешь NULL, будет ошибка.

Стратегии генерации ID

При добавлении новых записей нужно правильно генерировать Primary Key. В Java/Hibernate есть несколько стратегий:

1. IDENTITY (AUTO INCREMENT)

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

// Database: CREATE TABLE users (id BIGINT PRIMARY KEY AUTO_INCREMENT, ...)
// Значение id генерируется БД автоматически при INSERT

2. SEQUENCE

@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq")
@SequenceGenerator(name = "user_seq", sequenceName = "users_id_seq")
private Long id;

// Database: CREATE SEQUENCE users_id_seq START WITH 1;

3. TABLE

@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "user_gen")
@TableGenerator(name = "user_gen", table = "id_generator", pkColumnName = "entity", valueColumnName = "id_val")
private Long id;

// Значения хранятся в отдельной таблице

4. UUID

@Id
@GeneratedValue(strategy = GenerationType.UUID)
private UUID id;

// Генерируется UUID на уровне приложения

Ограничение на одновременные INSERT операции

При использовании IDENTITY или SEQUENCE может возникнуть проблема с выделением ID при массовых операциях. Hibernate пытается получить ID перед добавлением:

// Неэффективно: много отдельных INSERT
for (int i = 0; i < 1000; i++) {
    User user = new User();
    user.setEmail("user" + i + "@example.com");
    session.save(user);  // Каждый раз запрос ID из БД
}

// Лучше: batch insert
session.createMutationQuery(
    "INSERT INTO User (email) VALUES (:email)"
)
    .setParameter("email", "user@example.com")
    .executeUpdate();

Проблема с кешированием

Hibernate кеширует сущности по их primary key. Если попытаешься добавить две разные сущности с одинаковым ID, вторая будет проигнорирована:

User user1 = new User();
user1.setId(1L);
user1.setEmail("alice@example.com");
session.save(user1);

// Эта сущность НЕ будет добавлена, т.к. id=1 уже в кеше
User user2 = new User();
user2.setId(1L);
user2.setEmail("bob@example.com");
session.save(user2);

session.flush();
// В БД будет только одна запись с id=1 и email="alice@example.com"

Ограничения при использовании составного Primary Key

Когда Primary Key состоит из нескольких полей (composite key), ограничения усложняются:

@Entity
@IdClass(OrderItemId.class)
public class OrderItem {
    @Id
    private Long orderId;
    
    @Id
    private Long itemId;
    
    private int quantity;
}

// Оба поля одновременно должны быть уникальны
OrderItem item1 = new OrderItem();
item1.setOrderId(1L);
item1.setItemId(1L);
item1.setQuantity(5);
session.save(item1);

// Ошибка: такая комбинация уже существует
OrderItem item2 = new OrderItem();
item2.setOrderId(1L);
item2.setItemId(1L);  // Комбинация (1, 1) уже есть
item2.setQuantity(10);
session.save(item2);  // PRIMARY KEY constraint failed

Проблема версионирования при обновлении

Если используешь @Version для оптимистичной блокировки вместе с Primary Key:

@Entity
public class User {
    @Id
    private Long id;
    
    @Version
    private Long version;  // Для оптимистичной блокировки
    
    private String email;
}

// При INSERT версия должна быть NULL или 0
User user = new User();
user.setId(1L);
user.setEmail("test@example.com");
user.setVersion(null);  // Критично!
session.save(user);

Race conditions при генерации ID

В многопоточной среде могут возникнуть проблемы с генерацией ID:

@Transactional
public void addUsers(List<String> emails) {
    for (String email : emails) {
        User user = new User();  // ID выделится автоматически
        user.setEmail(email);
        userRepository.save(user);
    }
}

// В многопоточной среде два потока могут получить один и тот же ID
// Решение: использовать SEQUENCE с allocationSize

Лучшие практики

• Используй @GeneratedValue: Не пытайся генерировать ID вручную
• Предпочитай UUID или SEQUENCE: Они безопаснее IDENTITY в некоторых сценариях
• Проверяй уникальность перед добавлением: Используй findById() перед save()
• Избегай ручного установления ID: Только для миграции или специальных сценариев
• Тестируй на Unique constraint: Проверь, что нет дублирования в коде
• Используй batch операции: Для массовых INSERT, чтобы снизить количество запросов

Понимание этих ограничений критично для правильной работы с базой данных и избежания ошибок на production.