Course All lectures for TL purposes - Lecture: Pagtanggal ng isang bagay

Pag-alis gamit ang paraan ng remove().

Panghuli, tingnan natin ang pagtanggal ng isang bagay. Sa prinsipyo, ang pagtanggal ng mga bagay mula sa database ay napaka-simple, ngunit tulad ng sinasabi nila, may mga nuances. At mayroong anim na gayong mga nuances:

Pag-alis gamit ang paraan ng remove().
Pagtanggal para sa kumpanya
Pagtanggal ng Ulila
Tanggalin gamit ang JPQL
Pagtanggal sa pamamagitan ng NativeQuery
softDeleted()

At magsisimula tayo sa pinaka-halatang solusyon - ang pagtawag sa remove() method .

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.

Ang aktwal na operasyon sa database ay isasagawa pagkatapos tawagin ang flush() na paraan o ang transaksyon ay sarado.

Cascading delete

Naaalala mo ba noong nag-aral tayo ng SQL, ang mga dependent table ay maaaring isulat nang may CONSTRAINT. At ang isa sa kanila ay ganito:

CONSTRAINT ONDELETE REMOVE

Ang ibig sabihin nito ay kung mayroon tayong table na naglalaman ng mga child entity, kapag ang parent na entity ay inilaan, dapat tanggalin ang lahat ng mga anak nito.

Ipagpalagay na iniimbak namin ang personal na impormasyon ng user sa isang lugar at nag-set up ng CONSTRAINT sa database upang kapag na-delete ang user, tatanggalin din ang data na ito. Pagkatapos ay kailangan lang nating tanggalin ang parent object at lahat ng child object ay tatanggalin sa base level:

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.

Pagtanggal ng Ulila

Mayroon ding isa pang uri ng pagtanggal na tinatawag na Orphan removal. Ito ay medyo katulad sa nakaraang bersyon. Made-delete ang child entity kapag nasira ang kaugnayan nito sa parent na entity. Sa kasong ito, ang pangunahing entity ay karaniwang hindi tinatanggal.

Sabihin nating mayroon tayong user at mayroon siyang listahan ng mga post:

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

Mayroon ding mahalagang nuance, kung gusto nating ipatupad ng Hibernate ang pag-uugaling ito, dapat itong malinaw na tinukoy kapag nagli-link ng dalawang entity gamit ang mga anotasyon:

@Entity
public class User {

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

}

Tanggalin sa pamamagitan ng JPQL

Ang isa pang kawili-wiling paraan upang tanggalin ang isang bagay ay ang pagsulat ng query ng HQL (o JPQL). Basta huwag kalimutang tawagan ang executeUpdate() na paraan sa dulo , kung hindi, ang Hibernate ay gagawa ng read-only na transaksyon at hindi ka makakakuha ng anumang pagtanggal.

Halimbawa:

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();

Ang pagpapalit ng database ay hindi magbabago sa mga umiiral nang Entity object sa anumang paraan.

Pagtanggal sa pamamagitan ng NativeQuery

Katulad nito, maaari mong tanggalin at tawagan ang NativeQuery.

Halimbawa:

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();

Ang pagbabago sa database ay hindi makakaapekto sa mga umiiral nang Entity object sa anumang paraan.

Malambot na tanggalin

Minsan, sa halip na tanggalin ang data sa database, mas madaling markahan ito bilang tinanggal. Ang nasabing data ay maaaring lumahok sa iba't ibang mga sitwasyon. Una, ang naturang pagtanggal ay madaling mababalik - ang mga linya ay maaaring mamarkahan muli bilang live.

Pangalawa, kapaki-pakinabang na "i-archive" ang naturang malayuang data, dahil may mga kaso kapag ang pag-uugali ng server ay kinokontrol ng batas at iba pa. Gayunpaman, kung mamarkahan mo ang iyong data bilang tinanggal, ikaw lang ang makakaalam na natanggal na ito. Hahanapin pa rin ng hibernate ang data na ito at gagamitin din ito kapag nag-uuri.

Samakatuwid, ang mga tagalikha ng Hibernate ay gumawa ng isang espesyal na anotasyon kung saan posible na markahan ang mga bagay bilang buhay. Halimbawa:

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

Upang markahan ang isang bagay bilang tinanggal, kailangan mo lamang tawagan ang softDeleted() na pamamaraan dito :

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