Supprimer la requête Hibernate

Lorsque j'essaie de supprimer une entrée à partir d'une base, à l'aide de

session.delete(object)

alors je peux le suivant:

1) Si la ligne est présente dans la bd puis deux requêtes SQL sont l'obtention d'exécution: Une de sélectionner et de supprimer

2) Si la ligne n'est pas présente dans la base de données, puis seulement la requête select est arriver exécuté

Mais encore une fois ce n'est pas le cas pour la mise à jour. Indépendamment de la présence de DB lignes, seule la requête de mise à jour est prise en exécution.

S'il vous plaît laissez-moi savoir pourquoi ce genre de comportement pour l'opération de suppression. N'est-il pas un problème de performance depuis deux requêtes se faire frapper plutôt qu'un seul?

Edit:

Je suis de l'utilisation d'hibernate 3.2.5

Exemple de code:

SessionFactory sessionFactory = new Configuration().configure("student.cfg.xml").buildSessionFactory();
    Session session = sessionFactory.openSession();
    Student student = new Student();
    student.setFirstName("AAA");
    student.setLastName("BBB");
    student.setCity("CCC");
    student.setState("DDD");
    student.setCountry("EEE");
    student.setId("FFF");
    session.delete(student);
    session.flush();
            session.close();

cfg.xml

<property name="hibernate.connection.username">system</property>
    <property name="hibernate.connection.password">XXX</property>
    <property name="hibernate.connection.driver_class">oracle.jdbc.OracleDriver</property>
    <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521/orcl</property>      
    <property name="hibernate.jdbc.batch_size">30</property>
    <property name="hibernate.dialect">org.hibernate.dialect.OracleDialect</property>
    <property name="hibernate.cache.use_query_cache">false</property>
    <property name="hibernate.cache.use_second_level_cache">false</property>
    <property name="hibernate.connection.release_mode">after_transaction</property>
    <property name="hibernate.connection.autocommit">true</property>
    <property name="hibernate.connection.pool_size">0</property>
    <property name="hibernate.current_session_context_class">thread</property>    
    <property name="hibernate.show_sql">true</property>
    <property name="hibernate.hbm2ddl.auto">update</property>

hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.infy.model.Student" table="STUDENT">
    <id name="id" column="ID">
        <generator class="assigned"></generator>
    </id>
    <property name="firstName" type="string" column="FIRSTNAME"></property>
    <property name="lastName" type="string" column="LASTNAME"></property>
    <property name="city" type="string" column="CITY"></property>
    <property name="state" type="string" column="STATE"></property>
    <property name="country" type="string" column="COUNTRY"></property>        
</class>

Hibernate n'parfois faire un select avant une mise à Jour. Il dépend de l'état de l'objet est (persistante, transitoire ou détaché). Pour répondre à votre question, il sera utile de voir votre exemple de code.

InformationsquelleAutor user182944 | 2012-11-03

hibernate java

67

La raison en est que la suppression d'un objet, Hibernate exige que l'objet est dans l'état persistant. Ainsi, Hibernate premier extrait de l'objet (SÉLECTIONNER) et les supprimer (DELETE).

Pourquoi Hibernate a besoin de récupérer l'objet en premier? La raison en est que Hibernate intercepteurs peuvent être activés (http://docs.jboss.org/hibernate/orm/3.3/reference/en/html/events.html), et l'objet doit être transmis par le biais de ces intercepteurs pour compléter son cycle de vie. Si des lignes sont supprimer directement dans la base de données, l'intercepteur ne fonctionne pas.

D'autre part, il est possible de supprimer des entités en une seule SQL DELETE à l'aide des opérations en bloc:
```
Query q = session.createQuery("delete Entity where id = X");
q.executeUpdate();
```
- Dans ce cas, Pour la mise à jour de l'objet doit être dans la persistance de l'état de sorte qu'il peut être récupéré et ensuite mis à jour en droit?
- Non, pour qu'un objet soit supprimé, il peut être transitoire, deattached ou persistants de l'état. Je pense que le point avec votre code, c'est que vous êtes en train de créer un nouvel objet (état Transitoire), puis de le supprimer. Le fait que vous définissez l'id de l'objet, n'est-ce pas rendre un objet à partir de Transitoire de l'état Persistant (c'est toujours un Transitoire de l'objet). Pour cette raison, une fois la session.delete() est exécutée, il faut tout d'abord récupérer l'objet, de le stocker dans le contexte permanent (cache de premier niveau) et puis l'enlever.
- Si vous voulez faire un test, essayez de mettre votre objet avec un id n'est pas présent dans la base de données. Puis enregistrez-le avant de le supprimer, et ensuite faire le supprimer. Vous verrez comment les supprimer n'a pas besoin de faire une sélection car l'objet est déjà dans le cache de premier niveau (c'est un objet persistant).
- Merci pour la réponse. Oui, j'ai essayé d'enregistrer suivie par une suppression et il a travaillé comme vous l'avez suggéré. J'ai quelques questions: 1) Quand je attribuer l'id d'un objet est alors l'objet en état Transitoire ou détachés? Parce que d'après la doc, un état transitoire ne devrait pas avoir le numéro d'identification de l'objet de droit? 2) Si je change le générateur de classe à partir de assigned à native alors pourquoi le supprimer pas l'exécution de la requête select avant la suppression de la ligne? c'est à dire uniquement supprimer la requête est exécutée sans l'accord préalable de sélectionner. Pourquoi comme ça?
- Quand un objet est créé avec new() est dans un état Transitoire. Une passagère de l'objet est un objet qui n'a jamais été conservées dans la base de données (il n'y a pas de ligne en DB représentant l'objet). Un décollement de l'objet est un objet qui a été persisté au moins une fois (il y a donc une ligne en DB qui représente l'objet, ainsi que l'objet a un id), et qui est en dehors d'un contexte de session. Attribuer un id à un transitoire de l'objet ne fait pas l'objet devient persistante, est la save() l'opération qui le fait. Puis, quand l'objet persistant sort de la session contexte, l'objet se détache.
- Découvrez cette réponse sur les différents états d'un objet dans Hibernate stackoverflow.com/questions/2573739/... celui-ci est aussi bon: learningviacode.blogspot.com.es/2012/02/... à Propos de la question 2) je suis un peu casse-tête. Ce qui fait que n'est pas un SELECt est exécutée avant de le SUPPRIMER, c'est le fait que l'objet est dans la session (je veux dire, l'objet a été enregistré avant de le supprimer). Si ce n'est pas le cas, pourriez-vous collez votre code?
- Merci pour la réponse. Ainsi en est-il, comme: j'ai créé un objet, son identifiant à une valeur. Maintenant, si la valeur de l'identifiant n'est pas présent dans la DB l'objet est Transitoire, à nouveau, s'il est présent dans la bd alors qu'il est détaché à droite? Pour la seconde, non, je n'ai exactement le code que j'ai posté ci-dessus, uniquement de changer le générateur de assigned à native. Je n'ai pas de sauvegarder avant de le supprimer.
- besoin d'aide sur ce point 🙂
- La différence entre le transitoire et détachée de l'objet n'est pas seulement la présence d'une valeur d'id, mais plus important encore, si il y a une ligne dans la base de données représentant l'objet ou pas (non, dans le cas de transitoire; oui, dans le cas de décollement). Quant à l'autre question, j'ai besoin de l'écrire dans un autre commentaire 🙂 (c'est un peu long)
- Première chose, c'est que ça ne fait pas beaucoup de sens pour supprimer un transitoire de l'objet (il n'y a pas une ligne dans la base de données représentant l'objet). Dans le cas de la stratégie "attribuées", vous attribuer un id à l'objet. Lorsque la suppression est exécuté, Hibernate croit que l'objet était une fois stockées dans la bd (parce qu'il a un ID), donc il récupère l'objet (à cause de ce que j'ai expliqué avant) et puis le supprime. Dans le cas de la stratégie "native", vous n'avez pas besoin de définir l'id de l'objet (qui est gérer par Hibernate). Ce qu'il se passerait-il si Hibernate essaie de le récupérer? L'SÉLECTIONNEZ effectué, ce serait...
- ...quelque chose comme: SELECT * from X where id = null, toujours de retour à vide. Cette requête pourrait être ignorées, et Hibernate juste exécute SUPPRIMER. Mon avis (bien que j'aurais besoin de le vérifier à l'encontre de certains documents), c'est que dans le cas de l'transitoire de l'objet avec la stratégie "attribuées" Hibernate croit que l'objet est détaché, et tente de les récupérés avant de les supprimer. J'insiste sur le fait qu'il n'a pas beaucoup de sens de créer une nouvelle instance et de définir un identifiant (id, si ce que vous voulez est de supprimer un objet. L'objet doit exister dans la base de données avant de les supprimer, vous devez extraites de la session.get(id), puis l'enlever
- Merci beaucoup pour les explications 🙂
InformationsquelleAutor Diego Pino
22

Pour comprendre ce curieux comportement de mise en veille prolongée, il est important de comprendre quelques hibernate concepts -

Hibernate États D'Objet

Transitoire - Un objet est transitoire si elle a été
instanciée, et n'est pas encore associé à une session Hibernate.

Persistant - Une instance persistante a une représentation dans la
base de données et une valeur d'identifiant. Il pourrait avoir juste été enregistré ou
chargés, cependant, il est, par définition, dans le cadre d'une Session.

Détaché - Une instance détachée est un objet qui a été persistant,
mais sa Session a été fermée.

http://docs.jboss.org/hibernate/orm/3.3/reference/en/html/objectstate.html#objectstate-overview

Opération Write-Behind

La prochaine chose à comprendre, c'est 'Opération d'Écriture derrière". Lorsque des objets attachés à une session hibernate sont modifiés, ils ne sont pas immédiatement propagées à la base de données. Hibernate ne ce pour au moins deux raisons différentes.
- D'effectuer des insertions et mises à jour.
- Pour propager seule la dernière modification. Si un objet est mis à jour plus d'une fois, il a encore des feux qu'une instruction de mise à jour.
http://learningviacode.blogspot.com/2012/02/write-behind-technique-in-hibernate.html

Premier Niveau De Cache

Hibernate a quelque chose appelé " Premier Niveau de Cache. Chaque fois que vous passez un objet à save(), update() ou saveOrUpdate(), et chaque fois que vous récupérez un objet à l'aide load(), get(), list(), iterate() ou scroll(), cet objet est ajouté à l'intérieur de la cache de la Session. C'est là où il suit les modifications apportées à divers objets.

Hibernate Intercepters et l'Objet du Cycle de vie des Auditeurs -

De l'Intercepteur de l'interface et l'auditeur des rappels à partir de la session à la demande, autoriser l'application à vérifier et/ou de manipuler les propriétés d'un objet persistant avant de l'enregistrer, mises à jour, supprimées ou chargé.
http://docs.jboss.org/hibernate/orm/4.0/hem/en-US/html/listeners.html#d0e3069

Cette section à Jour

En cascade

Hibernate permet aux applications de définir cascade de relations entre les associations. Par exemple, 'cascade-delete' du parent à l'enfant d'association va entraîner la suppression de tous les enfants quand un parent est supprimé.

Alors, pourquoi sont-ils importants.

Pour être en mesure de faire des transactions d'écriture, pour être en mesure de suivre les multiples modifications apportées aux objets (objets graphiques) et d'être en mesure d'exécuter le cycle de vie des rappels hibernate a besoin de savoir si l'objet est transient/detached et il a besoin d'avoir l'objet en première mémoire cache de niveau avant de faire toute modification de l'objet sous-jacent et associé des relations.

C'est pourquoi hibernate (parfois) questions un 'SELECT' déclaration de charger l'objet (si c'est pas déjà chargé) à un premier niveau de cache avant de faire des modifications.

Pourquoi ne hibernate "SÉLECTIONNEZ" déclaration seulement parfois?

Hibernate questions un 'SELECT' instruction afin de déterminer quel est l'état de l'objet est dans. Si l'instruction select retourne un objet, l'objet est dans detached état et si elle ne renvoie pas à un objet, l'objet est dans transient état.

À venir de votre scénario -

Supprimer - Le "Supprimer" a publié une instruction SELECT, parce que hibernate a besoin de savoir si l'objet existe dans la base de données ou non. Si l'objet existe dans la base de données, hibernate considère comme detached et puis re-attches à la session et le processus de suppression de cycle de vie.

Mise à jour - Puisque vous êtes en appelant explicitement 'Update' au lieu de 'SaveOrUpdate', hibernate aveuglément suppose que l'objet est dans detached état, ré-attache de l'objet donné à la session de premier niveau de cache et les processus de la mise à jour de cycle de vie. Si il s'avère que l'objet n'existe pas dans la base de données contrairement à hibernate de l'assomption, une exception est levée lors de la session de bouffées de chaleur.

SaveOrUpdate - Si vous appelez 'SaveOrUpdate', hibernate a à déterminer l'état de l'objet, de sorte qu'il utilise une instruction SELECT pour déterminer si l'objet est dans Transient/Detached état. Si l'objet est dans transient état, il traite le 'insert' cycle de vie et si l'objet est dans detached état, il traite le 'Update' cycle de vie.
- J'ai posté un exemple de code, est l'objet dans l'état détaché?
- Oui, il est en état détaché. La première pensée serait qu'il est en Transitoire de l'état, mais puisque vous avez attribué un id de l'Étudiant, hibernate serait de le considérer comme détachée.
- Lorsque j'exécute le code ci-dessus avec generator = assigned, puis deux requêtes sont l'obtention d'exécution: sélectionnez suivie par la supprimer, mais si je change le générateur de native alors seulement la suppression est prise en exécution. Ainsi en est-il, l'objet n'est pas en état détaché lorsque le générateur est native même si je attribuer l'Id?
- Si vous utilisez la "générateur = affectés" et vous ne spécifiez pas un "unsaved-value', hibernate doit toujours aller à la base de données pour déterminer si un objet est transitoire ou détaché. Donc, il doit émettre un 'SELECT' instruction. Je ne suis pas sûr de savoir pourquoi il n'est pas l'émission d'un 'SELECT' déclaration 'générateur = native". La seule explication est que hibernate est de penser que l'objet est dans "transitoire" au lieu de "détaché". Pourriez-vous poster le code pour votre student.cfg.xml fichier?
- encore une fois, n'est pas la même chose va pour une mise à jour? Si je change le même code affiché ci-dessus delete à update alors qu'une requête est de se faire licencier. Alors pourquoi est-ce comme le update est dans un état persistant alors que delete est en état détaché?
- Désolé, s'il vous plaît poster student.hbm.xml ou le fichier de configuration hibernate pour les Étudiants de l'entité.
- posté le hbm fichier, le mettre en assigned dès maintenant
- Désolé, je suis pris au sujet de la mise à jour de cycle de vie. J'ai mis à jour ma réponse à refléter la même chose. Fondamentalement, les instructions SELECT sont émises afin de déterminer si l'objet est en Transitoire/Détaché " de l'état. Les objets en état transitoire ont différents événements de cycle de vie et de transformation à une autre logique que celles détaché de l'état selon le type d'opération (enregistrer/mettre à jour/supprimer) que nous essayons d'accomplir.
- Merci beaucoup pour la réponse 🙂 j'ai quelques questions: 1) je ne vois aucune exception imprimé dans ma console pour mettre à jour si l'objet n'est pas présent dans la bd. 2) Si je change le générateur de assigned à native alors seulement le supprimer est exécuté sans aucun requête select. Pourquoi ce comportement différent pour le natif alors?
- u peut me dire si l'exigence est de supprimer le parent et ensuite mettre à jour l'enfant étranger colonne avec une certaine valeur par défaut ou la valeur null comment il peut être fait
InformationsquelleAutor Sashi
3

Je ne suis pas sûr mais:
- Si vous appelez la méthode delete avec un non transitoire de l'objet, cela signifie d'abord récupéré l'objet de la DB. Il est donc normal de voir une instruction select. Peut-être en fin de compte vous voir 2 sélectionnez + 1 supprimer?
- Si vous appelez la méthode delete avec un transitoire de l'objet, alors il est possible que vous avez un cascade="delete" ou quelque chose de semblable, ce qui nécessite de récupérer d'abord l'objet, de sorte que "imbriqués" actions peut être effectuée que si elle est nécessaire.
Edit:
L'appel à delete() avec une instance éphémère signifie faire quelque chose comme ça:
```
MyEntity entity = new MyEntity();
entity.setId(1234);
session.delete(entity);
```
Cela permettra de supprimer la ligne avec l'id 1234, même si l'objet est un simple pojo pas récupérées par Hibernate, n'est pas présent dans son cache de session, ne sont pas gérés par Hibernate.

Si vous avez une entité association Hibernate probablement récupérer la totalité de l'entité afin qu'il sait si la suppression doit être mis en cascade pour les entités associées.
- Tout est dans la javadoc. Il est important de comprendre le cycle de vie d'une entité lors de l'utilisation d'Hibernate. docs.jboss.org/hibernate/orm/3.5/api/org/hibernate/...
InformationsquelleAutor Sebastien Lorber
1

au lieu d'utiliser

session.supprimer(objet)

utilisation
```
getHibernateTemplate().delete(object)
```
Dans les deux lieu pour select requête et également pour delete utilisation getHibernateTemplate()

Dans select requête, vous devez utiliser DetachedCriteria ou Criteria

Exemple pour la requête select
```
List<foo> fooList = new ArrayList<foo>();
DetachedCriteria queryCriteria = DetachedCriteria.forClass(foo.class);
queryCriteria.add(Restrictions.eq("Column_name",restriction));
fooList = getHibernateTemplate().findByCriteria(queryCriteria);
```
En veille prolongée éviter l'utilisation de la session,ici, je ne suis pas sûr mais le problème se produit juste à cause de l'utilisation
- pourquoi faut-il éviter à l'aide de session? pouvez-vous veuillez donner quelques nouvelles informations depuis votre explication n'est pas claire
- je suis également de l'utilisation d'hibernate dans mon toutes les applications,dans le passé, j'ai également face à des problèmes de même l'utilisation de la table avec plus de 2 requête feu dos à dos. après quelques recherches, j'ai la solution: éviter l'utilisation.il ne peut pas quitter/abandon/modifier n'importe quelle valeur que nous en avons besoin ou que nous avons pensé. et en session, à certains moments, vos données seront modifier/supprimer, sans mise à jour/supprimer la requête(juste à cause de l'utilisation). c'est mon expérience avec mise en veille prolongée dans les 2 dernières année.
- vous de vérifier la relation parent-enfant dans la db?, il peut également vous donner une erreur. ouverture bounty' question je suppose que vous avez déjà vérifié pour cela.
- où puis-je trouver les getHibernateTemplate() méthode? Pouvez-vous s'il vous plaît poster le pot de nom pour la même?
- de son partie du framework spring - télécharger le jar
- Pourrais-tu éditer ton post pour ajouter toutes les informations pertinentes? 🙂
InformationsquelleAutor Jubin Patel

Vous devez vous connecter pour publier un commentaire.