JPA: molti-a-uno unidirezionale e cancellazione a cascata

Supponiamo che io abbia una relazione unidirezionale @ManyToOne come la seguente:

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

Se ho un genitore P e figli C ₁ ... C _{n che fanno} riferimento a P, esiste un modo pulito e carino in JPA per rimuovere automaticamente i figli C ₁ ... C _n quando P viene rimosso (cioè entityManager.remove(P))?

Quello che sto cercando è una funzionalità simile a ON DELETE CASCADESQL.

Le relazioni in JPA sono sempre unidirezionali, a meno che non associ il genitore al bambino in entrambe le direzioni. Le operazioni REMOVE a cascata dal genitore al figlio richiederanno una relazione dal genitore al figlio (non solo l'opposto).

Dovrai quindi fare questo:

• In alternativa, modifica la @ManyToOnerelazione unidirezionale in bidirezionale @ManyToOneo unidirezionale @OneToMany. È quindi possibile eseguire operazioni REMOVE a cascata in modo da EntityManager.removerimuovere il genitore e i figli. Puoi anche specificare orphanRemovalcome true, per eliminare qualsiasi figlio orfano quando l'entità figlio nella raccolta genitore è impostata su null, ovvero rimuovere il figlio quando non è presente nella collezione di alcun genitore.
• Oppure, specifica il vincolo di chiave esterna nella tabella figlia come ON DELETE CASCADE. Sarà necessario richiamare EntityManager.clear()dopo la chiamata EntityManager.remove(parent)poiché il contesto di persistenza deve essere aggiornato: le entità figlio non dovrebbero esistere nel contesto di persistenza dopo che sono state eliminate nel database.

Se utilizzi l'ibernazione come provider JPA, puoi utilizzare l'annotazione @OnDelete. Questa annotazione aggiungerà alla relazione il trigger ON DELETE CASCADE , che delega la cancellazione dei figli al database.

Esempio:

public class Parent {

        @Id
        private long id;

}


public class Child {

        @Id
        private long id;

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

Con questa soluzione è sufficiente un rapporto unidirezionale dal bambino al genitore per rimuovere automaticamente tutti i figli. Questa soluzione non necessita di ascoltatori, ecc. Anche una query come DELETE FROM Parent WHERE id = 1 rimuoverà i figli.

Crea una relazione bidirezionale, come questa:

@Entity
public class Parent implements Serializable {

    @Id
    @GeneratedValue
    private long id;

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

Ho visto in @ManytoOne unidirezionale, l'eliminazione non funziona come previsto. Quando il genitore viene eliminato, idealmente anche il figlio dovrebbe essere eliminato, ma solo il genitore viene eliminato e il figlio NON viene eliminato e rimane orfano

Le tecnologie utilizzate sono Spring Boot / Spring Data JPA / Hibernate

Avvio Sprint: 2.1.2 RILASCIARE

Spring Data JPA / Hibernate viene utilizzato per eliminare la riga .eg

parentRepository.delete(parent)

ParentRepository estende il repository CRUD standard come mostrato di seguito ParentRepository extends CrudRepository<T, ID>

Di seguito sono riportate le mie classi di 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;


}

Usa questo metodo per eliminare solo un lato

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

Data l'annotazione ha funzionato per me. Puoi provare

Per esempio :-

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