JPA: suppression unidirectionnelle plusieurs-à-un et en cascade

Disons que j'ai une relation unidirectionnelle @ManyToOne comme celle-ci:

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

Si j'ai un parent P et des enfants C ₁ ... C _n renvoyant à P, y a-t-il un moyen propre et joli dans JPA de supprimer automatiquement les enfants C ₁ ... C _n lorsque P est supprimé (ie entityManager.remove(P))?

Ce que je recherche, c'est une fonctionnalité similaire à ON DELETE CASCADESQL.

Les relations dans JPA sont toujours unidirectionnelles, sauf si vous associez le parent à l'enfant dans les deux sens. Les opérations REMOVE en cascade du parent vers l'enfant nécessiteront une relation entre le parent et l'enfant (pas seulement l'inverse).

Vous devrez donc faire ceci:

• Soit, changez la @ManyToOnerelation unidirectionnelle en une relation bidirectionnelle @ManyToOneou unidirectionnelle @OneToMany. Vous pouvez ensuite mettre en cascade les opérations REMOVE afin de EntityManager.removesupprimer le parent et les enfants. Vous pouvez également spécifier orphanRemovalcomme vrai, pour supprimer tous les enfants orphelins lorsque l'entité enfant de la collection parent est définie sur null, c'est-à-dire supprimer l'enfant lorsqu'il n'est présent dans aucune collection parent.
• Ou, spécifiez la contrainte de clé étrangère dans la table enfant comme ON DELETE CASCADE. Vous devrez appeler EntityManager.clear()après l'appel EntityManager.remove(parent)car le contexte de persistance doit être actualisé - les entités enfants ne sont pas censées exister dans le contexte de persistance après avoir été supprimées dans la base de données.

Si vous utilisez hibernate comme fournisseur JPA, vous pouvez utiliser l'annotation @OnDelete. Cette annotation ajoutera à la relation le déclencheur ON DELETE CASCADE , qui délègue la suppression des enfants à la base de données.

Exemple:

public class Parent {

        @Id
        private long id;

}


public class Child {

        @Id
        private long id;

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

Avec cette solution, une relation unidirectionnelle de l'enfant au parent suffit pour supprimer automatiquement tous les enfants. Cette solution ne nécessite aucun écouteur, etc. Une requête telle que DELETE FROM Parent WHERE id = 1 supprimera les enfants.

Créez une relation bidirectionnelle, comme ceci:

@Entity
public class Parent implements Serializable {

    @Id
    @GeneratedValue
    private long id;

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

J'ai vu dans @ManytoOne unidirectionnel, supprimer ne fonctionne pas comme prévu. Lorsque le parent est supprimé, idéalement l'enfant devrait également être supprimé, mais seul le parent est supprimé et l'enfant n'est PAS supprimé et reste orphelin

Les technologies utilisées sont Spring Boot / Spring Data JPA / Hibernate

Démarrage du sprint: 2.1.2.RELEASE

Spring Data JPA / Hibernate est utilisé pour supprimer la ligne .eg

parentRepository.delete(parent)

ParentRepository étend le référentiel CRUD standard comme indiqué ci-dessous ParentRepository extends CrudRepository<T, ID>

Voici ma classe d'entité

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


}

Utilisez cette méthode pour supprimer un seul côté

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

Étant donné l'annotation a fonctionné pour moi. Peut avoir un essai

Par exemple :-

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