Ruhezustand: Wie kann sichergestellt werden, dass ein übergeordnetes Element nicht gelöscht wird, wenn alle untergeordneten Elemente vorhanden sind?

Question

Ich lösche entities und damit Zeilen aus meiner Datenbank.

I do möchten eine bestimmte Entität und alle ihre child Zeilen löschen. Jedoch möchte ich nicht löschen Zeilen aus seiner Parent.

Wie kann ich das erreichen?

ist die Parent Entity und Dog ist die Entität, die ich lösche.

Bitte siehe Code unten, wie ich die 2 im Zwinger Entity verknüpft haben:

@OneToMany(cascade = CascadeType.MERGE, orphanRemoval = false) 
    @JoinColumn(name = "KENNEL_ID", referencedColumnName = "ID", updatable = true, insertable = true) 
    private Set<Dog> dogs; 

Derzeit wenn ich Hund entitie löschen (s), die damit verbundenen Kennel Einheit wird auch gelöscht werden.

EDIT: Mapping von Hund zu Zwinger:

@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER) 
    @JoinColumn(name = "KENNEL_ID") 
    private kennel kennel; 

Answer 1

Derzeit wenn ich Hund Element (e), die dazugehörige Kennel Entität ebenfalls gelöscht löschen wird.

Der Grund dafür ist, dass Sie cascade=CascadeType.ALL auf ManyToOne Annotation gesetzt haben. Damit teilen wir dem ORM mit, dass beim Löschen (oder einer anderen Operation) Dog dieselbe Operation an die Entität weitergegeben werden soll.

Remove cascade attribute in ManyToOne(cascade = CascadeType.ALL). 

Kann ich halten die @OneToMany Beziehung im Zwinger gezeigt gleich?

Wenige Änderungen, die Sie berücksichtigen sollten.

• Keine Notwendigkeit JoinColumn Anmerkung an beiden oneToMany und ManyTone Seite zu haben.
• Verwenden Sie mappedBy="kennel" Attribut in OneToMany Annotation und entfernen Sie JoinColum Annotation auf OneToMany Seite. Dies macht ManyToOne die besitzende Seite und ist auch effizienter von SQLs, die generiert wird, wenn Sie kennel Entität beibehalten. Sie können es selbst überprüfen, indem Sie show_sql aktivieren.
• In Bezug auf cascade Attribut auf OneToMany, ob es auf ALL oder MERGE oder PERSIST, MERGE hängt davon ab, welche Operationen auf übergeordnete Entität mögen Sie untergeordnete Entität propagieren.
• Nicht sicher, ob Sie bereits Gerüstcode/Methoden implementiert haben, um die oneToMany-Beziehung hinzuzufügen/zu aktualisieren. Wenn nicht, ist es eine gute Idee, sie zu implementieren, da dies sicherstellt, dass die Verknüpfung an beiden Enden aktualisiert wird. Siehe scaffolding code, falls erforderlich.

Answer 2

Switched Ihren CascadeType.ALL Betrieb von untergeordneter Tabelle zu übergeordneter Tabelle nach Ihrem Bedarf.

Hier ist die einfache Lösung, die fast ähnlich dein ist, und es nach Bedarf auf anpassen.

@Entity(name = "Kennel") 
@Table(name = "Kennel") 
public class Kennel { 

    @Id 
    @Column(name = "Kennel_Id") 
    private long kennelId; 

    @Column(name = "Kennel_name") 
    private String KennelName; 

    //cascade = {CascadeType.REMOVE} OR orphanRemoval = true  
    @OneToMany(cascade = {CascadeType.ALL},orphanRemoval = true,fetch = fetchType.LAZY,mappedBy="dogKennel")  
    private Set<Dog> dogSet; 
    public long getKennelId() { 
     return kennelId; 
    } 

    public void setKennelId(long kennelId) { 
     this.kennelId = kennelId; 
    } 

    public String getKennelName() { 
     return KennelName; 
    } 

    public void setKennelName(String kennelName) { 
     KennelName = kennelName; 
    } 

    public Set<Dog> getDogSet() { 
     return dogSet; 
    } 

    public void setDogSet(Set<Dog> dogSet) { 
     this.dogSet = dogSet; 
    } 

} 

@Entity(name = "Dog") 
@Table(name = "Dog") 
public class Dog { 

    @Id 
    @Column(name = "Dog_Id") 
    private int dogId; 

    @ManyToOne 
    @JoinColumn(name = "Dog_Kennel_Id",referencedColumnName = "Kennel_Id") 
    private Kennel dogKennel; 

    @Column(name = "Dog_Name") 
    private String dogName; 

    public int getDogId() { 
     return dogId; 
    } 

    public void setDogId(int dogId) { 
     this.dogId = dogId; 
    } 

    public Kennel getDogKennel() { 
     return dogKennel; 
    } 

    public void setDogKennel(Kennel dogKennel) { 
     this.dogKennel = dogKennel; 
    } 

    public String getDogName() { 
     return dogName; 
    } 

    public void setDogName(String dogName) { 
     this.dogName = dogName; 
    } 

} 



//adding kennel=1 and dog=1 
     Kennel ken=new Kennel(); 
     ken.setKennelId(1); 
     ken.setKennelName("KennelExample1");   
     HashSet<Dog> myDogSet=new HashSet<Dog>();  
     Dog dog=new Dog(); 
     dog.setDogId(1); 
     dog.setDogName("ExampleDog1"); 
     dog.setDogKennel(ken); 
     myDogSet.add(dog); 
     ken.setDogSet(myDogSet);   
     kennelRepo.save(ken); 

     //adding dog=2 under kennel=1 
     Dog dog2=new Dog(); 
     dog2.setDogId(2); 
     dog2.setDogName("ExampleDog2"); 
     Kennel dog2ken=new Kennel(); 
     dog2ken.setKennelId(1);  
     dog2.setDogKennel(dog2ken); 
     dogRepo.save(dog2); 

     //adding dog=3 under kennel=1 
     Dog dog3=new Dog(); 
     dog3.setDogId(3); 
     dog3.setDogName("ExampleDog3"); 
     Kennel dog3ken=new Kennel(); 
     dog3ken.setKennelId(1); 
     dog3.setDogKennel(dog3ken); 
     dogRepo.save(dog3); 

     //deleting dog=3 
     dog3=new Dog(); 
     dog3.setDogId(3); 
     dogRepo.delete(dog3); 

     //deleting kennel=1 which in turn delete all dogs under 
     Kennel k=kennelRepo.findByKennelId(1); 
     kennelRepo.delete(k);