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;

Using “JoinTable” results in the creation of a special table

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

  @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;

Results in

campuses

campusparts

campus_campuspart

Omitting the “JoinTable” results in embedding the Foreign key campus_id - into the CampusPart table

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

  @ManyToOne(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
  private ECampus campus;

Results in

campuses

campusparts

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<>();
  
}

ManyToMany relationships can lead to inconsitancies when

• settings links back
• there are multiple entities linking, back to parents
• entities have inconsistant list of members

Seems like when wiring entities, which are affected on both sides - it should happen in 1 transaction.

In Spring boot you need to annotate a method with @Transactional

https://thorben-janssen.com/transactions-spring-data-jpa/

@Service
@Getter
public class EquipmentService {

    @Autowired
    private EquipmentRepository equipmentRepository;
     
    @Transactional
    public void updateEquipmentFeeds(ResourcePK equipmentFeeds, ResourcePK equipmentTarget) {
        Assert.isTrue(equipmentFeeds.getPartitionId().equals(equipmentTarget.getPartitionId()), "Only allow feeds in same partition");
        Equipment e1 = equipmentRepository.findById(equipmentFeeds).get();
        Equipment e2 = equipmentRepository.findById(equipmentTarget).get();
        e1.getFeeds().add(e2);
        equipmentRepository.save(e1);
    } 
}

    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinTable(name="FeedsRel",
            joinColumns={
                    @JoinColumn(
                            name = "feedsrel_child_id",
                            referencedColumnName = "id"),
                    @JoinColumn(
                            name = "feedsrel_child_partitionId",
                            referencedColumnName = "partitionId")
            })
    private Set<Equipment> feeds = new HashSet<Equipment>();


    // Associations marked as mappedBy must not define database mappings like @JoinTable or @JoinColumn
    @ManyToMany( cascade = CascadeType.ALL, mappedBy="feeds", fetch = FetchType.EAGER)
    private Set<Equipment> fedBy = new HashSet<Equipment>();