JPA: unidirektionales Viele-zu-Eins- und kaskadierendes Löschen

Angenommen, ich habe eine unidirektionale @ManyToOne Beziehung wie die folgende:

@Entity
public class Parent implements Serializable {

    @Id
    @GeneratedValue
    private long id;
}

@Entity
public class Child implements Serializable {

    @Id
    @GeneratedValue
    private long id;

    @ManyToOne
    @JoinColumn
    private Parent parent;  
}

Wenn ich ein Elternteil P und Kinder C ₁ ... C _{n habe,} die auf P zurückgreifen, gibt es in JPA eine saubere und hübsche Möglichkeit, die Kinder C ₁ ... C _n automatisch zu entfernen, wenn P entfernt wird (dh entityManager.remove(P))?

Was ich suche, ist eine Funktionalität ähnlich wie ON DELETE CASCADEin SQL.

Beziehungen in JPA sind immer unidirektional, es sei denn, Sie ordnen den Elternteil dem Kind in beide Richtungen zu. Das Kaskadieren von REMOVE-Operationen vom Elternteil zum Kind erfordert eine Beziehung vom Elternteil zum Kind (nicht nur das Gegenteil).

Sie müssen daher Folgendes tun:

• Ändern Sie entweder die unidirektionale @ManyToOneBeziehung in eine bidirektionale @ManyToOneoder eine unidirektionale @OneToMany. Sie können dann REMOVE-Vorgänge kaskadieren, EntityManager.removeum die übergeordneten und untergeordneten Elemente zu entfernen. Sie können auch orphanRemovaltrue angeben , um verwaiste untergeordnete Elemente zu löschen, wenn die untergeordnete Entität in der übergeordneten Auflistung auf null gesetzt ist, dh das untergeordnete Element zu entfernen, wenn es in der übergeordneten Auflistung nicht vorhanden ist.
• Oder geben Sie die Fremdschlüsseleinschränkung in der untergeordneten Tabelle als an ON DELETE CASCADE. Sie müssen nach dem Aufruf EntityManager.clear()aufrufen, EntityManager.remove(parent)da der Persistenzkontext aktualisiert werden muss. Die untergeordneten Entitäten dürfen nach dem Löschen in der Datenbank nicht im Persistenzkontext vorhanden sein.

Wenn Sie den Ruhezustand als JPA-Anbieter verwenden, können Sie die Anmerkung @OnDelete verwenden. Diese Anmerkung fügt der Beziehung den Auslöser ON DELETE CASCADE hinzu , der das Löschen der untergeordneten Elemente an die Datenbank delegiert.

Beispiel:

public class Parent {

        @Id
        private long id;

}


public class Child {

        @Id
        private long id;

        @ManyToOne
        @OnDelete(action = OnDeleteAction.CASCADE)
        private Parent parent;
}

Mit dieser Lösung reicht eine unidirektionale Beziehung vom Kind zum Elternteil aus, um alle Kinder automatisch zu entfernen. Diese Lösung benötigt keine Listener usw. Auch eine Abfrage wie DELETE FROM Parent WHERE id = 1 entfernt die untergeordneten Elemente .

Erstellen Sie eine bidirektionale Beziehung wie folgt:

@Entity
public class Parent implements Serializable {

    @Id
    @GeneratedValue
    private long id;

    @OneToMany(mappedBy = "parent", cascade = CascadeType.REMOVE)
    private Set<Child> children;
}

Ich habe in unidirektionalem @ManytoOne gesehen, Löschen funktioniert nicht wie erwartet. Wenn ein Elternteil gelöscht wird, sollte im Idealfall auch ein Kind gelöscht werden, aber nur das Elternteil wird gelöscht und das Kind wird NICHT gelöscht und als Waise belassen

Die verwendete Technologie ist Spring Boot / Spring Data JPA / Hibernate

Sprint Boot: 2.1.2.RELEASE

Spring Data JPA / Hibernate wird zum Löschen der Zeile .eg verwendet

parentRepository.delete(parent)

ParentRepository erweitert das Standard-CRUD-Repository wie unten gezeigt ParentRepository extends CrudRepository<T, ID>

Im Folgenden sind meine Entitätsklassen aufgeführt

@Entity(name = “child”)
public class Child  {

    @Id
    @GeneratedValue
    private long id;

    @ManyToOne( fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = “parent_id", nullable = false)
    @OnDelete(action = OnDeleteAction.CASCADE)
    private Parent parent;
}

@Entity(name = “parent”)
public class Parent {

    @Id
    @GeneratedValue
    private long id;

    @Column(nullable = false, length = 50)
    private String firstName;


}

Verwenden Sie diese Methode, um nur eine Seite zu löschen

    @ManyToOne(cascade=CascadeType.PERSIST, fetch = FetchType.LAZY)
//  @JoinColumn(name = "qid")
    @JoinColumn(name = "qid", referencedColumnName = "qid", foreignKey = @ForeignKey(name = "qid"), nullable = false)
    // @JsonIgnore
    @JsonBackReference
    private QueueGroup queueGroup;

@Cascade (org.hibernate.annotations.CascadeType.DELETE_ORPHAN)

Die gegebene Anmerkung hat bei mir funktioniert. Kann es versuchen

Zum Beispiel :-

     public class Parent{
            @Id
            @GeneratedValue(strategy=GenerationType.AUTO)
            @Column(name="cct_id")
            private Integer cct_id;
            @OneToMany(cascade=CascadeType.REMOVE, fetch=FetchType.EAGER,mappedBy="clinicalCareTeam", orphanRemoval=true)
            @Cascade(org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
            private List<Child> childs;
        }
            public class Child{
            @ManyToOne(fetch=FetchType.EAGER)
            @JoinColumn(name="cct_id")
            private Parent parent;
    }