JPA / Hibernate — Relations, mappings & collections

@Entity
class Stock {
    @Id Long id;

    @ManyToOne(fetch = FetchType.LAZY)   // ✓ LAZY par défaut
    @JoinColumn(name = "address_id")
    Address address;
}

@Entity
class Address {
    @OneToMany(mappedBy = "address")   // ✓ lecture seule pour SQL
    List<Stock> stocks = new ArrayList<>();
}

@Entity
class Stock {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "address_id")   // ✓ propriétaire de la FK
    Address address;
}

// ❌ BUG SILENCIEUX — modifie uniquement l'inverse side
address.getStocks().add(stock);
// → aucune exception, aucun SQL, FK null en base

// ✓ PATTERN OBLIGATOIRE — toujours synchroniser les deux côtés
public void addStock(Stock stock) {
    stocks.add(stock);
    stock.setAddress(this);   // ✓ modifie la owning side
}

public void removeStock(Stock stock) {
    stocks.remove(stock);
    stock.setAddress(null);   // ✓ modifie la owning side
}

@OneToMany(mappedBy = "address", orphanRemoval = true)
List<Stock> stocks;

// ❌ List sans @OrderColumn — DELETE ALL + INSERT ALL sur tout changement
@OneToMany(mappedBy = "order")
List<OrderLine> lines;   // BAG

// SQL réel pour un seul ajout :
// DELETE FROM order_line WHERE order_id = 1
// INSERT INTO order_line ... (toutes les lignes, y compris la nouvelle)

// ✓ Set — INSERT ciblé (si equals/hashCode corrects)
@OneToMany(mappedBy = "order")
Set<OrderLine> lines;
// SQL réel : INSERT INTO order_line ... (uniquement la nouvelle)

// ❌ MAUVAIS — basé sur champs mutables → Hibernate perd l'identité de l'entité
@Override
public boolean equals(Object o) {
    Stock other = (Stock) o;
    return Objects.equals(location, other.location);
}

// ✓ CORRECT — basé sur ID technique
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Stock other = (Stock) o;
    return Objects.equals(id, other.id);
}

@Override
public int hashCode() { return Objects.hash(id); }

@Entity
class User {
    @Id Long id;

    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "address_id", unique = true)  // ✓ UNIQUE pour garantir le 1-1
    Address address;

    @OneToOne(mappedBy = "user")   // ✓ côté inverse — pas de SQL
    UserProfile profile;
}

@Entity
class UserProfile {
    @Id Long id;   // même ID que User

    @OneToOne
    @MapsId          // ✓ utilise l'ID de User comme PK — pas de colonne FK supplémentaire
    @JoinColumn(name = "id")
    User user;

    String bio;
    String avatar;
}

@Entity
class Student {
    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    Set<Course> courses = new HashSet<>();
}

@ManyToOne
@JoinColumn(
    name = "customer_id",               // nom de la colonne FK
    referencedColumnName = "code",      // référence customer.code au lieu de customer.id (défaut = PK)
    nullable = false,                   // NOT NULL
    foreignKey = @ForeignKey(name = "fk_order_customer")  // nom de la contrainte
)
Customer customer;

@Entity
class Order {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    Customer customer;   // ✓ écrit la FK

    // ✓ expose la FK comme Long sans charger l'entité Customer
    @Column(name = "customer_id", insertable = false, updatable = false)
    Long customerId;
}

// Usage : lire la FK sans déclencher le lazy loading
Long customerId = order.getCustomerId();  // pas de SELECT sur customer

@ManyToOne
@JoinColumns({
    @JoinColumn(name = "stock_product_id", referencedColumnName = "productId"),
    @JoinColumn(name = "stock_location_id", referencedColumnName = "locationId")
})
Stock stock;