JPA: eliminación unidireccional de varios a uno y en cascada

Di que tengo un unidireccional @ManyToOne relación como la siguiente:

@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 tengo un padre P e hijos C ₁ ... C _n haciendo referencia a P, ¿hay una forma limpia y bonita en JPA de eliminar automáticamente a los hijos C ₁ ... C _n cuando se elimina P (es decir entityManager.remove(P))?

Lo que estoy buscando es una funcionalidad similar a ON DELETE CASCADESQL.

Las relaciones en JPA son siempre unidireccionales, a menos que asocie al padre con el hijo en ambas direcciones. Las operaciones REMOVE en cascada del padre al hijo requerirán una relación del padre al hijo (no solo lo contrario).

Por lo tanto, deberá hacer esto:

• O cambie la @ManyToOnerelación unidireccional a bidireccional @ManyToOneo unidireccional @OneToMany. A continuación, puede realizar operaciones REMOVE en cascada para EntityManager.removeeliminar el padre y los hijos. También puede especificar orphanRemovalcomo verdadero, para eliminar cualquier hijo huérfano cuando la entidad hijo en la colección principal se establece en nula, es decir, eliminar el hijo cuando no está presente en la colección principal.
• O especifique la restricción de clave externa en la tabla secundaria como ON DELETE CASCADE. Deberá invocar EntityManager.clear()después de llamar, EntityManager.remove(parent)ya que el contexto de persistencia debe actualizarse; se supone que las entidades secundarias no deben existir en el contexto de persistencia después de que se hayan eliminado en la base de datos.

Si está usando hibernate como su proveedor de JPA, puede usar la anotación @OnDelete. Esta anotación agregará a la relación el disparador ON DELETE CASCADE , que delega la eliminación de los hijos a la base de datos.

Ejemplo:

public class Parent {

        @Id
        private long id;

}


public class Child {

        @Id
        private long id;

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

Con esta solución, una relación unidireccional del niño al padre es suficiente para eliminar automáticamente a todos los niños. Esta solución no necesita oyentes, etc. Además, una consulta como DELETE FROM Parent WHERE id = 1 eliminará los hijos.

Crea una relación bidireccional, como esta:

@Entity
public class Parent implements Serializable {

    @Id
    @GeneratedValue
    private long id;

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

He visto en @ManytoOne unidireccional, eliminar no funciona como se esperaba. Cuando se elimina el padre, lo ideal es que el niño también se elimine, pero solo se elimina el padre y el niño NO se elimina y se deja como huérfano

Las tecnologías utilizadas son Spring Boot / Spring Data JPA / Hibernate

Arranque de Sprint: 2.1.2.RELEASE

Spring Data JPA / Hibernate se usa para eliminar la fila .eg

parentRepository.delete(parent)

ParentRepository extiende el repositorio CRUD estándar como se muestra a continuación ParentRepository extends CrudRepository<T, ID>

Los siguientes son mi clase de entidad

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


}

Utilice esta forma para eliminar solo un lado

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

La anotación dada funcionó para mí. Puede intentarlo

Por ejemplo :-

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