web-dev-qa-db-fra.com

Comment supprimer par critères en veille prolongée?

J'ai une table d'étudiants et je veux supprimer tous les étudiants d'une classe.

Donc, ma requête SQL ressemblerait à ceci:

delete from student where classId = 333

Comment puis-je faire cela en utilisant la mise en veille prolongée avec des critères? 

J'ai besoin de cela pour pouvoir utiliser l'une de mes classes de base et l'utiliser avec les objets DAO qui en sortent. Je peux donc rendre cela générique dans tous mes objets DAO.

Actuellement, j'ai créé une méthode générique qui sera prise dans l'objet Student - appelle la méthode find qui utilise les critères pour obtenir la liste, puis effectue une suppression par lot dans une transaction, comme suit:

public boolean deleteByCriteria(Object deleteObject) {
    List deleteObjectList = find(deleteObject);
    if (deleteObjectList == null)
        return false;
    return deleteAll(deleteObjectList);
}

public boolean deleteAll(List deleteObjectList) {
    if (logger.isDebugEnabled()) {
        logger.debug("Entered BaseSchoolRollBookDAO -> delete");
        logger.debug("Object for batch deletion [" + deleteObjectList + "]");
    }
    boolean result = false;
    Transaction tx = null;
    // Get CurrentSession from HibernateUtils
    Session session = HibernateUtils.getSession();
    // Start transaction
    tx = session.beginTransaction();

    // Create new Criteria to be passed
    try {
        int flushCount = 0;
        for (Object deleteObject : deleteObjectList) {
            session.delete(deleteObject);
            flushCount++;

            if (flushCount % 20 == 0) {
                session.flush();
                session.clear();
            }
        }           

        tx.commit();
        result = true;
    } catch (HibernateException e) {
        logger.fatal("Exception in executing batch Delete query", e);
        if (tx != null && tx.isActive())
            tx.rollback(); 
    }
    return result;
}
javahibernate
34
chan

Pour supprimer , utilisez HQL qui est la meilleure option , je pense, Les critères le but principal est uniquement de récupérer les données.
Celui-ci est avec Criteria

  Student student = (Student ) session.createCriteria(Student.class)
                    .add(Restrictions.eq("classId", classId)).uniqueResult();
  session.delete(student);

Et celle-ci est une requête HQL simple:

String hql = "delete from Student where classId= :classId";
session.createQuery(hql).setString("classId", classId).executeUpdate();
68
Õzbek

Vous pouvez facilement y parvenir en suivant en mode hibernation simple, comme suit:

Session session=getSession();  
String hql = "delete from Student where classId= :id"; 
session.createQuery(hql).setLong("id", new Integer(id)).executeUpdate();

pour plus de détails voir

8
Shams

Celui-ci est le meilleur moyen et meilleur que la réponse de @Jama Asatillayev . Parce que vous n'avez pas à récupérer d'abord l'objet persistant. 

Product product = new Product();
product.setId(37);
session.delete(product);

Et hibernate va courir:

Hibernate: delete from PRODUCT where PRODUCT_ID=?

Plus de détails: http://www.codejava.net/frameworks/hibernate/hibernate-basics-3-ways-to-delete-an-entity-from-the-datastore

4
İsmail Yavuz

Vous devez mettre à niveau votre version de veille prolongée vers une version qui implémente JPA 2.1 (Hibernate lance JPA 2.1 sur la version 4.3.11.Final - Téléchargements Hibernate ) 

Une fois que vous avez mis à jour, vous pouvez utiliser CriteriaDelete pour faire ce que vous voulez. Voici un petit exemple: Exemple

3
Rodrigo R. Coelho

Vous pouvez utiliser des critères pour en condition 

public Integer deleteByFieldIn(String Field, Iterable<?> values) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaDelete<T> delete = cb.createCriteriaDelete(getDomainClass());
    Root<T> e = delete.from(getDomainClass());
    delete.where(cb.in(e.get(Field)).value(values));
    return entityManager.createQuery(delete).executeUpdate();
}

et Vous pouvez utiliser la même chose pour une condition égale en remplaçant en égal à comme

public Integer deleteById(String id) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaDelete<T> delete = cb.createCriteriaDelete(getDomainClass());
    Root<T> e = delete.from(getDomainClass());
    delete.where(cb.equal(e.get("id"), id));
    return entityManager.createQuery(delete).executeUpdate();
}
1
Maulik Kakadiya

Je sais que je suis assez tard pour la fête, mais si vous utilisez JPA 2.1, vous pouvez le faire de cette façon ...

https://iblyts-on-Java.org/criteria-updatedelete-easy-way-to/

 public void deleteOrder(Double amount) {
    CriteriaBuilder cb = this.em.getCriteriaBuilder();

    // create delete
    CriteriaDelete<Order> delete = cb.
     createCriteriaDelete(Order.class);

    // set the root class
    Root e = delete.from(Order.class);

    // set where clause
    delete.where(cb.lessThanOrEqualTo(e.get("amount"), amount));

    // perform update
    this.em.createQuery(delete).executeUpdate();
}
0
Sanjeev Dhiman
 /**
 * 
 * @param objects
 */
 public static void deleteAll(List<?> objects) {

            try {
                HibernateEntityManager em = JPA.em().unwrap(HibernateEntityManager.class);
                Session session = em.getSession();
                for (Object o : objects) {
                    session.delete(o);
                }
            } catch (Exception e) {
                Logger.error("CommonHibernateBD_deleteAll error: " + e);
                e.printStackTrace();
            }

     }
0
onacione