Tohuwabohu excorcism

Tutorials: http://viralpatel.net/blogs/hibernate-one-to-many-annotation-tutorial/

In examples there is:

• One Department has many employees
• One Employee has one deparment

ACHTUNG:

• Bei OneToMany, ManyToOne bezieht sich der erste Teil auf die Klasse, in welcher die annotierte Variable befindet.
  Wenn wir in der Klasse Department das Set employees annotieren - dann steht dort @OneToMany. Weil One Department Many employees hat.

Then the modelling will look as following:

@Entity
@Table(name="EMPLOYEE")
public class Employee {
  
    @ManyToOne
    @JoinColumn(name="department_id")
    private Department department;
}
@Entity
@Table(name="DEPARTMENT")
public class Department{
  
    @OneToMany(mappedBy="department")
    private Set<Employee> employees;
}

Discriminators are used for for storing class hierarchies in a single table. If having RedCar.class inheriting from Car.class - both stored in one table, then discriminator tells - hwne t orestore a RedCar and when t orestore a Car.

The element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row.

Details: http://docs.jboss.org/hibernate/core/3.5/reference/en-US/html/mapping.html#mapping-declaration-discriminator

The Domain Model looks as following

Campus -is-> Location
CampusPart -is-> Location

Campus -hasmany-> CampusPart

Introduce a Superclass with an ID.

@MappedSuperclass
@Table(name = "locations", schema = "public")
public abstract class ELocation {

    @Id
    @Column(name = "ID", unique = true, nullable = false, insertable = false, updatable = false)
    protected UUID id = UuidCreator.getSequential();
}

Here Both Entities Campus and CampuPart have a Link on each other. This is called a BiDirectional modeling

• Owning-side vs. inverse-side https://www.baeldung.com/hibernate-one-to-many

Introduce an ECampusPart Here the JoinTable is on CampusPart, so it is the owning-side of the connection.

@Entity(name = "ECampusPart")
@Table(name = "campusparts", schema = "public")
public class ECampusPart extends ELocation  {


  /*
    Modeling a bidirectional relationship here.

    JoinTable means - that relationships will be extracted explicitely to an own table.
    Allows to explicitely name the columns: campuspart_id and campus_id here

   */
  @ManyToOne(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
  @JoinTable(
          name = "campus_campuspart",
          joinColumns = {@JoinColumn(name = "campuspart_id")},
          inverseJoinColumns = {@JoinColumn(name = "campus_id")}
  )
  private ECampus campus;

Introduce an ECampus. Here the mappedBy is on Campus, so it is the inverse-side of the connection.

@Entity(name="ECampus")
@Table(name = "campuses", schema = "public")
public class ECampus extends ELocation  {

  @OneToMany(mappedBy = "campus", cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
  private Set<ECampusPart> campusParts = new HashSet<>();
  
}