Objektum törlése

Eltávolítás a remove() metódussal

Végül nézzük meg egy objektum törlését. Elvileg az objektumok törlése az adatbázisból nagyon egyszerű, de ahogy mondják, vannak árnyalatok. És hat ilyen árnyalat van:

• Eltávolítás a remove() metódussal
• Eltávolítás a cég számára
• Eltávolítás Árva által
• Törölje a JPQL-lel
• Törlés a NativeQuery segítségével
• softDeleted()

És kezdjük a legkézenfekvőbb megoldással - a remove() metódus meghívásával .

User user = new User();
user.setName("Kolyan");
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
session.remove(user);
session.flush();
session.clear();  // close the session

//here the object is actually deleted.

A tényleges művelet az adatbázisban a flush() metódus meghívása vagy a tranzakció lezárása után kerül végrehajtásra.

Lépcsőzetes törlés

Emlékszel, amikor az SQL-t tanulmányoztuk, a függő táblákat CONSTRAINT segítségével lehetett írni. És az egyik így szólt:

CONSTRAINT ONDELETE REMOVE

Ennek az volt a jelentése, hogy ha van egy táblánk, amely utód entitásokat tartalmaz, akkor a szülő entitás lefoglalásakor minden gyermekét törölni kell.

Tegyük fel, hogy valahol tároljuk a felhasználó személyes adatait, és beállítjuk a CONSTRAINT-t az adatbázisban, hogy a felhasználó törlésekor ezek az adatok is törlésre kerüljenek. Ezután csak a szülőobjektumot kell törölnünk, és az összes gyermek objektum törlődik az alapszinten:

User user = new User();
UserPrivateInfo info = new UserPrivateInfo();
user.setPrivateInfo(info);
session.persist(user);  //add the object to the database, the info object will also be saved to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
session.remove(user);
session.flush();
session.clear();  // close the session

// here the user and info objects are actually removed from the database.

Eltávolítás Árva által

Van egy másik típusú eltávolítás is, az úgynevezett árva eltávolítás. Kicsit hasonlít az előző verzióhoz. Az utód entitás akkor törlődik, ha a szülőentitással való kapcsolata megszakad. Ebben az esetben a szülő entitás általában nem törlődik.

Tegyük fel, hogy van egy felhasználónk, és van egy listája a bejegyzésekről:

User user = new User();
UserMessage message = new UserMessage();
user.getMessageList().add(message);
session.persist(user);  //add the object to the database, the message object will also be saved to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
UserMessage message2 = user.getMessageList().get(0); //get the user's message
user.getMessageList().remove(message2);  //remove the message from the list
session.flush();
session.clear();  // close the session

// here the message2 object is actually removed from the database

Van egy fontos árnyalat is, ha azt akarjuk, hogy a Hibernate megvalósítsa ezt a viselkedést, akkor ezt kifejezetten meg kell adni, amikor két entitást annotációkkal összekapcsolunk:

@Entity
public class User {

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    private List<UserMessage> messageList = new ArrayList<UserMessage>();

}

Törlés JPQL-n keresztül

Az objektumok törlésének másik érdekes módja egy HQL (vagy JPQL) lekérdezés írása. Csak ne felejtse el meghívni az executeUpdate() metódust a végén , különben a Hibernate csak olvasható tranzakciót hoz létre, és Ön nem fog törlést kapni.

Példa:

User user = new User();
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

session.createQuery("delete from User where id = :id")
   .setParameter("id", user.getId())
   .executeUpdate();

Az adatbázis módosítása semmilyen módon nem módosítja a meglévő entitás objektumokat.

Törlés a NativeQuery segítségével

Hasonlóképpen törölheti és hívhatja a NativeQueryt.

Példa:

User user = new User();
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

session.createNativeQuery("DELETE FROM user WHERE id = :id")
   .setParameter("id", user.getId())
   .executeUpdate();

Az adatbázis változása semmilyen módon nem érinti a meglévő Entitás objektumokat.

Lágy törlés

Néha az adatok törlése helyett kényelmesebb, ha egyszerűen töröltként jelöli meg azokat. Az ilyen adatok különböző forgatókönyvekben szerepelhetnek. Először is, egy ilyen törlés könnyen visszafordítható - a sorok ismét élőként jelölhetők meg.

Másodszor, hasznos az ilyen távoli adatok „archiválása”, mert vannak esetek, amikor a szerver viselkedését törvény és hasonlók szabályozzák. Ha azonban töröltként jelöli meg adatait, akkor csak Ön fogja tudni, hogy azokat törölték. A Hibernate továbbra is megtalálja ezeket az adatokat, és a rendezés során is felhasználja.

Ezért a Hibernate készítői egy speciális annotációval rukkoltak elő, amellyel élőként lehetne megjelölni a tárgyakat. Példa:

@Entity
@Where(clause = "DELETED = 0") //in all WHEREs "AND DELETED = 0" will be added
public class User {
	// mapping fields

	@Column(name = "DELETED") // if the value in the DELETED column == 0, then the record is alive, if 1 - dead
	private Integer deleted = 0;

	//getters and setters

    public void softDeleted() {
    	this.deleted = 1; //mark the post as dead
    }
}

Ha töröltként szeretne megjelölni egy objektumot, csak meg kell hívnia a softDeleted() metódust :

User user = new User();
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
user.softDeleted(); // mark the object as deleted
session.flush();
session.clear();  // close the session

//this object will no longer reside via Hibernate