Hibernate hql, exécute plusieurs instructions de mise à jour dans la même requête

En bref, ce que vous recherchez est quelque chose comme le dosage en JDBC. Thich n'est pas fournie par Hibernate pour Vrac requête de mise à Jour, et je doute que va jamais être considéré pour la mise en veille prolongée.

À partir de mon expérience passée, la fonction de traitement par lot pour HQL est rarement utile dans la vie réelle. Il peut sembler étrange que quelque chose est utile dans SQL+JDBC, mais pas dans les requêtes HQL. Je vais essayer d'expliquer.

Généralement, lorsque l'on travail avec mise en veille prolongée (ou d'autres ORM), nous travaillons à l'encontre des entités. Hibernate sera responsable de synchroniser nos entités de l'état avec la DB, ce qui est généralement le cas que JDBC dosage peuvent aider à améliorer les performances. Cependant, dans Hibernate on ne change pas à chaque entité de l'état en Vrac requête de mise à Jour.

Juste donner un exemple, en pseudo-code:

Dans JDBC, vous pouvez faire quelque chose comme (je suis en train d'essayer d'imiter ce que vous montrez dans votre exemple):

List<Order> orders = findOrderByUserId(userName);
for (Order order: orders) {
    if (order outstanding quantity is 0) {
        dbConn.addBatch("update ORDER set STATE='C' where ID=:id", order.id);
    } else if (order is after expriation time) {
        dbConn.addBatch("delete ORDER where ID=:id", order.id);
    }
}
dbConn.executeBatch();

Naïf de traduction à partir de JDBC logique de mise en veille prolongée peut vous donner quelque chose comme ceci:

List<Order> orders = findOrderByUserId(userName);
for (Order order: orders) {
    if (order outstanding quantity is 0) {
        q = session.createQuery("update Order set state='C' where id=:id");
        q.setParameter("id", order.id);
        q.executeUpdate();
    } else if (order is after expriation time) {
        q = session.createQuery("delete Order where id=:id");
        q.setParameter("id", order.id);
        q.executeUpdate();
    }
}

Je soupçonne que vous pensez que vous avez besoin de la fonction de traitement par lot parce que vous faites quelque chose de similaire (selon votre exemple, vous utilisez la mise à jour en bloc pour chaque enregistrement). Toutefois, il est PAS comment la chose devrait être fait dans Hibernate/JPA,

(En fait, il est préférable d'envelopper la couche de persistance de l'accès par le biais d'un référentiel, ici, je suis juste à la simplification de l'image)

List<Order> orders = findOrderByUserId(userName);
for (Order order: orders) {
    if (order.anyOutstanding()) {
        order.complete();    //which internally update the state
    } else if (order.expired) {
        session.delete(order);
    }
}

session.flush();   //or you may simply leave it to flush automatically before txn commit

Ce faisant, Hibernate est assez intelligent pour détecter modifiés/supprimés/inséré entités, et de rendre l'utilisation de JDBC lot pour faire de la DB de la CUD opérations à flush(). Le plus important, c'est le but entier de l'ORM: nous voulons offrir le comportement riche entités de travailler avec, pour les internes de modification de l'état des entités peut être de façon "transparente" réfléchie dans le stockage persistant.

HQL mise à Jour en bloc vise pour un autre usage, qui est quelque chose comme une mise à jour en bloc DB à affecter un grand nombre d'enregistrements, par exemple:

q = session.createQuery("update Order set state='C' " 
                        + " where user.id=:user_id "
                        + " and outstandingQty = 0 and state != 'C' ");
q.setParameter("user_id", userId);
q.executeUpdate();

Il est rarement nécessaire pour l'exécution d'un lot de requêtes dans ce genre de scénario d'utilisation, par conséquent, les frais généraux de la DB aller-retour est insignifiant, et, par conséquent, de prestations et de traitement par lots de soutien pour le vrac requête de mise à jour est rarement significative.

Je ne peux pas omettre qu'il y a des cas que vous avez vraiment besoin d'émettre beaucoup de requêtes de mise à jour qui n'est pas approprié de faire une véritable entité comportement. Dans de tels cas, vous pouvez vouloir reconsidérer si Hibernate est le bon outil pour être utilisé. Vous pouvez envisager d'utiliser pur JDBC dans de tels cas d'utilisation de sorte que vous avez le contrôle sur la façon dont les requêtes sont émises.

dans le même executeUpdate appel je veux mettre à jour des enregistrements dans le tableau 1 et
supprimer des enregistrements à partir de Table2.

Est-ce possible?

executeUpdate() exécute une seule requête de mise à jour.
Donc, non, vous ne pouvez pas le faire. Vous avez à réaliser que de nombreuses requêtes de mise à jour sous forme de tables à mettre à jour/supprimer.
En outre, il fait un code plus propre si vous avez des requêtes distinctes :

• les requêtes sont plus facile à lire et le réglage des paramètres est lisible et de ne pas faire des erreurs.
• pour déboguer l'exécution de la requête, il serait plus facile à comprendre si les requêtes sont traitées une par une dans leur propre executeUpdate()

Cela ne veut pas dire que les requêtes doivent obligatoirement être transmisent un par un.

Le Traitement par lots est une fonctionnalité fournie par Hibernate pour améliorer les performances lorsque vous voulez exécuter de multiples requêtes. Vous devez l'activer pour pouvoir l'utiliser.
hibernate.jdbc.batch_size propriété doit être définie avec une valeur appropriée.

Si vous êtes l'entreprise de traitement par lots, vous devez activer le
l'utilisation de JDBC de traitement par lots. C'est absolument essentiel si vous voulez
atteindre une performance optimale. Définir le JDBC lot de taille raisonnable
nombre (de 10 à 50, par exemple):

mise en veille prolongée.jdbc.batch_size 20 Hibernate désactive insérer le dosage à l'
JDBC niveau de manière transparente si vous utilisez une identité identificateur de générateur.

En plus de la documentation officielle :

Hibernate désactive insérer le dosage à l'JDBC niveau de manière transparente si
vous utilisez une identité identificateur de générateur.

Néanmoins, dans votre cas, il sera inutile parce que Dragan Bozanovic expliqué mise à jour/supprimer des tables dans vos requêtes. Donc, il serait de créer autant de lots exécutions interrogé tables.

Donc, vous devez exécuter chaque requête individuelle. Juste commit() de la transaction lorsque vous le jugez il devrait être :

hql = "update Table1 set prob1=null where id=:id1;"
...
query.setParameter("id1",...);
query.executeUpdate();
hql = "delete from Table2 where id =:id2";
...
query.executeUpdate();
query.setParameter("id2",...);
..
tx.commit();

Pourquoi ne pas exécuter deux requêtes séparément dans une méthode

En annotant la méthode avec @Transactional, si la requête échoue, l'autre ne sera pas exécuté.

 @Transactional(propagation = Propagation.REQUIRED, readOnly = false)

 public void executeQuery(Obj1 obj1) {

 String query="update table1 set actualRepaymentAmount=expectedRepaymentAmount,active='Y'  where loanCaseId = '"+caseId+"'";
        sessionFactory.getCurrentSession().createQuery(query).executeUpdate();

 query="update table2 set loanStatus='C' where loanCaseId = '"+caseId+"'";  
    sessionFactory.getCurrentSession().createQuery(query).executeUpdate();

        ...

 }