JPA: muitos-para-um unidirecional e exclusão em cascata

Digamos que eu tenha um relacionamento unidirecional @ManyToOne como o seguinte:

@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 eu tiver um pai P e filhos C ₁ ... C _n referenciando P, existe uma maneira limpa e bonita em JPA de remover automaticamente os filhos C ₁ ... C _n quando P é removido (isto é entityManager.remove(P))?

O que procuro é uma funcionalidade semelhante ao ON DELETE CASCADESQL.

Os relacionamentos em JPA são sempre unidirecionais, a menos que você associe o pai ao filho em ambas as direções. As operações REMOVE em cascata dos pais para os filhos exigirão uma relação dos pais para os filhos (não apenas o oposto).

Portanto, você precisará fazer o seguinte:

• Altere o @ManyToOnerelacionamento unidirecional para bidirecional @ManyToOneou unidirecional @OneToMany. Você pode então colocar em cascata as operações REMOVE para EntityManager.removeremover o pai e os filhos. Você também pode especificar orphanRemovalcomo verdadeiro, para excluir quaisquer filhos órfãos quando a entidade filha na coleção pai for definida como nula, ou seja, remover o filho quando não estiver presente em nenhuma coleção pai.
• Ou especifique a restrição de chave estrangeira na tabela filha como ON DELETE CASCADE. Você precisará invocar EntityManager.clear()após a chamada, EntityManager.remove(parent)pois o contexto de persistência precisa ser atualizado - as entidades filhas não deveriam existir no contexto de persistência depois de terem sido excluídas do banco de dados.

Se você estiver usando o hibernate como seu provedor JPA, poderá usar a anotação @OnDelete. Esta anotação adicionará à relação a trigger ON DELETE CASCADE , que delega a exclusão dos filhos ao banco de dados.

Exemplo:

public class Parent {

        @Id
        private long id;

}


public class Child {

        @Id
        private long id;

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

Com esta solução, um relacionamento unidirecional do filho para o pai é suficiente para remover automaticamente todos os filhos. Esta solução não precisa de nenhum ouvinte, etc. Além disso, uma consulta como DELETE FROM Parent WHERE id = 1 removerá os filhos.

Crie uma relação bidirecional, como esta:

@Entity
public class Parent implements Serializable {

    @Id
    @GeneratedValue
    private long id;

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

Eu vi em @ManytoOne unidirecional, a exclusão não funciona como esperado. Quando o pai é excluído, o ideal é que o filho também seja excluído, mas apenas o pai é excluído e o filho NÃO é excluído e fica órfão

A tecnologia usada é Spring Boot / Spring Data JPA / Hibernate

Inicialização Sprint: 2.1.2.RELEASE

Spring Data JPA / Hibernate é usado para excluir a linha.

parentRepository.delete(parent)

ParentRepository estende o repositório CRUD padrão como mostrado abaixo ParentRepository extends CrudRepository<T, ID>

A seguir estão minha classe de entidade

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


}

Use esta forma para apagar apenas um 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)

A anotação dada funcionou para mim. Pode tentar

Por exemplo :-

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