The scenario is as following: each table can have many reservations, and each reservation can span many tables. Here is our first trial:

// Table.java
@ManyToMany(
  targetEntity=Reservation.class
)
public List getReservations() {..}

// Reservation.java
@ManyToMany(
  targetEntity=Table.class
)
public List getTables() {..}

We end up with linktables tables_reservations and reservations_tables. This is not what we want. It shouldn’t be possible to remove a table when there are still reservations related to that table. We change our code so that table becomes the owner of the relationship.

// Table.java
@ManyToMany(
  targetEntity=Reservation.class,
  mappedBy="tables"
)
public List getReservations() {..}

Allright, now we only have the linktable reservations_tables. Exactly the same as we experienced with OneToMany relationships the cascading persist works when we persist a child (reservation). If we want the cascading persist to work when we persist a parent (table) we have to make sure that the child (reservation) has the parent set. An important difference is that we can’t enforce this thus i advise not to use the cascade attribute on the owner (table).

// Table.java
@ManyToMany(
  targetEntity=Reservation.class,
  mappedBy="tables"
)
public List getReservations() {..}

// Reservation.java
@ManyToMany(
  targetEntity=Table.class,
  cascade=CascadeType.PERSIST
)
public List getTables() {..}

We decide to use the Hibernate Validator classes to enforce that a reservation is associated with at least one table. For some reason the SizeValidator returns true if the value is null thus we also add a NotNullValidator:

// Reservation.java
import org.hibernate.validator.*;
@ManyToMany(
  targetEntity=Table.class,
  cascade=CascadeType.PERSIST
)
@NotNull
@Size(min=1)
public List getTables() { .. }

Ok, this allows us to enforce that reservations are always associated with at least one table. We decide to allow cascading persist on the parent.

@ManyToMany(
  targetEntity=Reservation.class,
  mappedBy="tables",
  cascade=CascadeType.PERSIST
)
public List getReservations() {..}

Let’s experiment a bit with Hibernate. We want to model the tables employee and shift. Each employee has multiple shifts (and each shift belongs to an employee). We want an employee table and a shift table (which has the employee_id as a foreign key).

// Employee.java
@OneToMany(targetEntity=Shift.class) public List getShifts() {...}
// Shift.java
@ManyToOne public Employee getEmployee() {...}

The code above generates the following tables: employee, employee_shift and shift. Time to read the documentation and discover the mappedBy attribute.

// Employee.java
@OneToMany(targetEntity=Shift.class, mappedBy="employee") public List getShifts() {...}

Ok, now we get the tables we want. Let’s remove an employee that has shifts referencing him. An exception is thrown because of a foreign key constraint.

// Employee.java
@OneToMany(targetEntity=Shift.class, mappedBy="employee", cascade=CascadeType.REMOVE) public List getShifts() {...}

Ok, now we have cascading deletes working. Let’s try cascading inserts:

// Employee.java
@OneToMany(targetEntity=Shift.class, mappedBy="employee", cascade=CascadeType.ALL) public List getShifts() {...}
// Main.java
Employee employee = new Employee();
Shift shift = new Shift();
Vector shifts = new Vector();
shifts.add(shift);
employee.setShifts(shifts);
em.persist(employee);

With the code above the foreign key of shift will NULL instead of the employee_id. According to the documentation it is expected behaviour that cascading inserts only work when the children are saved.

// Employee.java
@OneToMany(targetEntity=Shift.class, mappedBy="employee", cascade=CascadeType.ALL) public List getShifts() {...}
// Main.java
Employee employee = new Employee();
Shift shift = new Shift();
shift.setEmployee(employee);
Vector shifts = new Vector();
shifts.add(shift);
employee.setShifts(shifts);
em.persist(employee);

It appears we can get cascading inserts to work as long as we don’t forget to set the employee. We add a constraint so employee can’t be null.

// Shift.java
@ManyToOne @Column(nullable=false) public Employee getEmployee() {...}
// Main.java
Shift shift = new Shift();
em.persist(shift);

WTF? I can persist a NULL reference anyway? The value for employee_id is allowed to be NULL? Have we found a bug? Let’s check the documentation:

// Shift.java
@ManyToOne @JoinColumn(nullable=false) public Employee getEmployee() {...}
// Main.java
Shift shift = new Shift();
em.persist(shift);

Ok, now are getting somewhere. And exception is thrown if we try to persist a shift that references to an employee that doesn’t exist in the database yet.

// Shift.java
@ManyToOne(cascade=CascadeType.PERSIST) @JoinColumn(nullable=false) public Employee getEmployee() {...}

CascadeType.ALL means that i want to cascade events on ALL events. My only requirements where that i cascade on PERSIST (insert) and on REMOVE (delete). So i need to change my annotation as following:

// Employee.java
@OneToMany(
  targetEntity=Shift.class,
  mappedBy="employee",
  cascade={
    CascadeType.PERSIST,
    CascadeType.REMOVE
  }
)
public List getShifts() {return shifts;}