Hibernate example source code file (transactions.po)

This example Hibernate source code file (transactions.po) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Hibernate tags/keywords

cmt, ejb, hibernate, hibernate, il, in, jdbc, jta, jta, tag, tag, the, the, this

The Hibernate transactions.po source code

# translation of transactions.po to French
# Myriam Malga <mmalga@redhat.com>, 2007.
# Xi HUANG <xhuang@redhat.com>, 2007.
# Corina Roe <croe@redhat.com>, 2009, 2010.
# translation of Collection_Mapping.po to
msgid ""
msgstr ""
"Project-Id-Version: transactions\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-11T05:38:16\n"
"PO-Revision-Date: 2010-01-05 10:06+1000\n"
"Last-Translator: Corina Roe <croe@redhat.com>\n"
"Language-Team: French <i18@redhat.com>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"

#. Tag: title
#, no-c-format
msgid "Transactions and Concurrency"
msgstr "Transactions et Accès concurrents"

#. Tag: para
#, no-c-format
msgid ""
"The most important point about Hibernate and concurrency control is that it "
"is easy to understand. Hibernate directly uses JDBC connections and JTA "
"resources without adding any additional locking behavior. It is recommended "
"that you spend some time with the JDBC, ANSI, and transaction isolation "
"specification of your database management system."
msgstr ""
"L'un des principaux avantages du mécanisme de contrôle des accès concurrents "
"de Hibernate est qu'il est très facile à comprendre. Hibernate utilise "
"directement les connexions JDBC ainsi que les ressources JTA sans y ajouter "
"davantage de mécanisme de blocage. Nous vous recommandons de vous "
"familiariser avec les spécifications JDBC, ANSI et d'isolement de "
"transaction du système de gestion de la base de données que vous utilisez. "

#. Tag: para
#, no-c-format
msgid ""
"Hibernate does not lock objects in memory. Your application can expect the "
"behavior as defined by the isolation level of your database transactions. "
"Through <literal>Session, which is also a transaction-scoped "
"cache, Hibernate provides repeatable reads for lookup by identifier and "
"entity queries and not reporting queries that return scalar values."
msgstr ""
"Hibernate ne verrouille pas vos objets en mémoire. Votre application peut "
"suivre le comportement défini par le niveau d'isolation de vos transactions "
"de base de données. Notez que grâce à la <literal>Session, qui est "
"aussi un cache de portée de transaction, Hibernate fournit des lectures "
"répétées pour les recherches par identifiants et les requêtes d'entités (ne "
"rapporte pas les requêtes qui retournent des valeurs scalaires). "

#. Tag: para
#, no-c-format
msgid ""
"In addition to versioning for automatic optimistic concurrency control, "
"Hibernate also offers, using the <literal>SELECT FOR UPDATE "
"syntax, a (minor) API for pessimistic locking of rows. Optimistic "
"concurrency control and this API are discussed later in this chapter."
msgstr ""
"En plus du versioning, pour le contrôle automatique optimiste de "
"concurrence, Hibernate fournit également une API (mineure) pour le "
"verrouillage pessimiste des lignes, en générant une syntaxe <literal>SELECT "
"FOR UPDATE</literal>. Le contrôle de concurrence optimiste et cette API "
"seront approfondis ultérieurement dans ce chapitre. "

#. Tag: para
#, no-c-format
msgid ""
"The discussion of concurrency control in Hibernate begins with the "
"granularity of <literal>Configuration, SessionFactorySession, as well as database transactions "
"and long conversations."
msgstr ""
"Nous abordons la gestion des accès concurrents en discutant de la "
"granularité des objets <literal>Configuration, "
"<literal>SessionFactory, et Session, ainsi que "
"des transactions de la base de données et des longues transactions "
"applicatives. "

#. Tag: title
#, no-c-format
msgid "Session and transaction scopes"
msgstr "Portées des sessions et des transactions"

#. Tag: para
#, no-c-format
msgid ""
"A <literal>SessionFactory is an expensive-to-create, threadsafe "
"object, intended to be shared by all application threads. It is created "
"once, usually on application startup, from a <literal>Configuration est "
"un objet complexe et optimisé pour fonctionner avec les threads(thread- "
"safe). Il est coûteux à créer et est ainsi prévu pour n'être instancié "
"qu'une seule fois via une instance <literal>Configuration en "
"général au démarrage de l'application. "

#. Tag: para
#, no-c-format
msgid ""
"A <literal>Session is an inexpensive, non-threadsafe object that "
"should be used once and then discarded for: a single request, a conversation "
"or a single unit of work. A <literal>Session will not obtain a "
"JDBC <literal>Connection, or a Datasource, "
"unless it is needed. It will not consume any resources until used."
msgstr ""
"Une <literal>Session n'est pas coûteuse, et c'est un objet non-"
"threadsafe qui ne devrait être utilisé qu'une seule fois pour une requête "
"unique, une conversation, une unité de travail unique et devrait être "
"relâché ensuite. Un objet <literal>Session ne tentera pas "
"d'obtenir une <literal>ConnectionJBDC (ou une Datasource span several database transactions, or is this a "
"one-to-one relationship of scopes? When should you open and close a "
"<literal>Session and how do you demarcate the database transaction "
"boundaries? These questions are addressed in the following sections."
msgstr ""
"Quelle est la portée d'une unité de travail? Est-ce qu'une <literal>Session et "
"comment définir les démarcations de vos transactions à la base de données ? "

#. Tag: title
#, no-c-format
msgid "Unit of work"
msgstr "Unité de travail"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"First, let's define a unit of work. A unit of work is a design pattern "
"described by Martin Fowler as <quote> [maintaining] a list of objects "
"affected by a business transaction and coordinates the writing out of "
"changes and the resolution of concurrency problems. </quote>PoEAAPoEAA. En d'autres termes, il "
"s'agit d'une série d'opérations que nous voulons réaliser ensemble sur la "
"base de données. Il s'agit essentiellement d'une transaction, bien qu'en "
"remplissant une unité de travail, on couvrira souvent plusieurs transactions "
"physiques de base de données (voir <xref linkend=\"transactions-basics-apptx"
"\" />). Nous parlons donc vraiment une notion plus abstraite de transaction. "
"Le terme \"business transaction\"est aussi parfois utilisé à la place "
"d'unité de travail."

#. Tag: para
#, no-c-format
msgid ""
"Do not use the <emphasis>session-per-operation antipattern: do "
"not open and close a <literal>Session for every simple database "
"call in a single thread. The same is true for database transactions. "
"Database calls in an application are made using a planned sequence; they are "
"grouped into atomic units of work. This also means that auto-commit after "
"every single SQL statement is useless in an application as this mode is "
"intended for ad-hoc SQL console work. Hibernate disables, or expects the "
"application server to disable, auto-commit mode immediately. Database "
"transactions are never optional. All communication with a database has to "
"occur inside a transaction. Auto-commit behavior for reading data should be "
"avoided, as many small transactions are unlikely to perform better than one "
"clearly defined unit of work. The latter is also more maintainable and "
"extensible."
msgstr ""
"Tout d'abord n'utilisez pas l'anti-pattern <emphasis>session-par-operationSession à "
"chacun de vos accès simples à la base de données dans un même thread ! Par "
"conséquent, le même raisonnement est applicable à la gestion des "
"transactions dans la base de données. Dans une application, les appels à la "
"base de données doivent être effectués selon une séquence ordonnée et sont "
"regroupés en unités de travail atomiques. (Notez que l'utilisation d'une "
"connexion auto-commit après chaque déclaration SQL est inutile dans une "
"application. Ce mode de fonctionnement existe pour les applications émettant "
"des commandes SQL ad-hoc à partir d'une console. Hibernate désengage le mode "
"auto-commit et s'attend à ce qu'un serveur d'applications le fasse "
"également.) Les transactions avec la base de données ne sont jamais "
"optionnelles. Toute communication avec une base de données doit se dérouler "
"dans une transaction, peu importe si vous lisez ou écrivez des données. "
"Comme déjà mentionné, le comportement auto-commit pour lire les données "
"devrait être évité, puisque plusieurs petites transactions ne seront jamais "
"aussi efficaces qu'une seule plus grosse clairement définie comme unité de "
"travail. Ce dernier choix est de plus beaucoup plus facile à maintenir et "
"plus extensible."

#. Tag: para
#, no-c-format
msgid ""
"The most common pattern in a multi-user client/server application is "
"<emphasis>session-per-request. In this model, a request from the "
"client is sent to the server, where the Hibernate persistence layer runs. A "
"new Hibernate <literal>Session is opened, and all database "
"operations are executed in this unit of work. On completion of the work, and "
"once the response for the client has been prepared, the session is flushed "
"and closed. Use a single database transaction to serve the clients request, "
"starting and committing it when you open and close the <literal>Session Hibernate est ouverte et toutes les opérations "
"d'accès à la base de données sont exécutées à l'intérieur de celle-ci. "
"Lorsque le travail est terminé (et que les réponses à envoyer au client ont "
"été préparées), la session est flushée et fermée. Une seule transaction à la "
"base de données peut être utilisée pour répondre à la requête du client. La "
"transaction est démarrée et validée au même moment où la Session est ouverte "
"et fermée. La relation entre la <literal>Session et la "
"<literal>Transaction est donc un-à-un. Cette relation entre les "
"deux est un-à-un et ce modèle permet de répondre parfaitement aux attentes "
"de la grande majorité des applications. "

#. Tag: para
#, no-c-format
msgid ""
"The challenge lies in the implementation. Hibernate provides built-in "
"management of the \"current session\" to simplify this pattern. Start a "
"transaction when a server request has to be processed, and end the "
"transaction before the response is sent to the client. Common solutions are "
"<literal>ServletFilter, AOP interceptor with a pointcut on the "
"service methods, or a proxy/interception container. An EJB container is a "
"standardized way to implement cross-cutting aspects such as transaction "
"demarcation on EJB session beans, declaratively with CMT. If you use "
"programmatic transaction demarcation, for ease of use and code portability "
"use the Hibernate <literal>Transaction API shown later in this "
"chapter."
msgstr ""
"Le défi réside dans l'implémentation. Hibernate fournit une fonction de "
"gestion intégrée de la \"session courante\" pour simplifier ce pattern. Il "
"vous suffit de démarrer une transaction lorsqu'une requête est traitée par "
"le serveur, et la terminer avant que la réponse ne soit envoyée au client. "
"Vous pouvez choisir la manière de l'effectuer, les solutions communes sont "
"un <literal>ServletFilter, l'interception via AOP avec une coupe "
"transverse (pointcut) sur les méthodes de type \"service\", ou un conteneur "
"avec interception/proxy. Un conteneur EJB est un moyen standard "
"d'implémenter ce genre d'acpect transverse comme la démarcation des "
"transactions sur les EJB  session, de manière déclarative avec CMT. Si vous "
"décidez d'utiliser la démarcation programmatique des transactions, préferrez "
"l'API Hibernate <literal>Transaction traitée plus tard dans ce "
"chapitre, afin de faciliter l'utilisation et la portabilité du code. "

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Your application code can access a \"current session\" to process the "
"request by calling <literal>sessionFactory.getCurrentSession(). "
"You will always get a <literal>Session scoped to the current "
"database transaction. This has to be configured for either resource-local or "
"JTA environments, see <xref linkend=\"architecture-current-session\" />."
msgstr ""
"Votre application peut accéder à une \"session courante\" pour traiter une "
"requête en invoquant simplement <literal>sessionFactory.getCurrentSession() dont la portée est la transaction "
"courante avec la base de données. Ceci doit être configuré soit dans les "
"ressources locales ou dans l'environnement JTA, voir <xref linkend="
"\"architecture-current-session\" />."

#. Tag: para
#, no-c-format
msgid ""
"You can extend the scope of a <literal>Session and database "
"transaction until the \"view has been rendered\". This is especially useful "
"in servlet applications that utilize a separate rendering phase after the "
"request has been processed. Extending the database transaction until view "
"rendering, is achieved by implementing your own interceptor. However, this "
"will be difficult if you rely on EJBs with container-managed transactions. A "
"transaction will be completed when an EJB method returns, before rendering "
"of any view can start. See the Hibernate website and forum for tips and "
"examples relating to this <emphasis>Open Session in View pattern."
msgstr ""
"Il est parfois utile d'étendre la portée d'une <literal>Session et "
"d'une transaction à la base de données jusqu'à ce que \"la vue soit rendue"
"\". Ceci est particulièrement utile dans des applications à base de servlet "
"qui utilisent une phase de rendue séparée une fois que la réponse a été "
"préparée. Étendre la transaction avec la base de données jusqu'à la fin du "
"rendering de la vue est aisé si vous implémentez votre propre intercepteur. "
"Cependant, ce n'est pas facile si vous vous appuyez sur les EJB avec CMT, "
"puisqu'une transaction sera achevée au retour de la méthode EJB, avant le "
"rendu de la vue. Rendez vous sur le site Hibernate et sur le forum pour des "
"astuces et des exemples sur le pattern <emphasis>Open Session in View and database transaction. "
"The user is free to modify the objects."
msgstr ""
"Un écran s'affiche. Les données vues par l'usager ont été chargées dans "
"l'instance d'un objet <literal>Session , dans le cadre d'une "
"transaction de base de données. L'usager est libre de modifier ces objets. "

#. Tag: para
#, no-c-format
msgid ""
"The user clicks \"Save\" after 5 minutes and expects their modifications to "
"be made persistent. The user also expects that they were the only person "
"editing this information and that no conflicting modification has occurred."
msgstr ""
"L'usager clique \"Sauvegarder\" après 5 minutes et souhaite persister les "
"modifications qu'il a apportées. Il s'attend à être la seule personne a "
"avoir modifié ces données et qu'aucune modification conflictuelle ne se soit "
"produite durant ce laps de temps. "

#. Tag: para
#, no-c-format
msgid ""
"From the point of view of the user, we call this unit of work a long-running "
"<emphasis>conversation or application transaction (ou transaction d'application and "
"database transaction open during user think time, with locks held in the "
"database to prevent concurrent modification and to guarantee isolation and "
"atomicity. This is an anti-pattern, since lock contention would not allow "
"the application to scale with the number of concurrent users."
msgstr ""
"Une première implémentation naïve pourrait consister à garder la "
"<literal>Session et la transaction à la base de données ouvertes "
"durant le temps de travail de l'usager, à maintenir les enregistrements "
"verrouillés dans la base de données afin d'éviter des modifications "
"concurrentes et de maintenir l'isolation et l'atomicité de la transaction de "
"l'usager. Ceci est un anti-pattern à éviter, puisque le verrouillage des "
"enregistrements dans la base de données ne permettrait pas à l'application "
"de gérer un grand nombre d'usagers concurrents. "

#. Tag: para
#, no-c-format
msgid ""
"You have to use several database transactions to implement the conversation. "
"In this case, maintaining isolation of business processes becomes the "
"partial responsibility of the application tier. A single conversation "
"usually spans several database transactions. It will be atomic if only one "
"of these database transactions (the last one) stores the updated data. All "
"others simply read data (for example, in a wizard-style dialog spanning "
"several request/response cycles). This is easier to implement than it might "
"sound, especially if you utilize some of Hibernate's features:"
msgstr ""
"Il apparaît donc évident qu'il faille utiliser plusieurs transactions BDD "
"afin d'implémenter la conversation. Dans ce cas, maintenir l'isolation des "
"processus d'affaire devient partiellement la responsabilité de la couche "
"applicative. Ainsi, la durée de vie d'une conversation devrait englober "
"celle d'une ou de plusieurs transactions de base de données. Celle-ci sera "
"atomique seulement si l'écriture des données mises à jour est faite "
"exclusivement par la dernière transaction BDD la composant. Toutes les "
"autres sous transactions BD ne doivent faire que la lecture de données. Ceci "
"est relativement facile à mettre en place, surtout avec l'utilisation de "
"certaines fonctionnalités d'Hibernate :"

#. Tag: para
#, no-c-format
msgid ""
"<emphasis>Automatic Versioning: Hibernate can perform automatic "
"optimistic concurrency control for you. It can automatically detect if a "
"concurrent modification occurred during user think time. Check for this at "
"the end of the conversation."
msgstr ""
"<emphasis>Versionnage Automatique - Hibernate peut gérer "
"automatiquement les accès concurrents de manière optimiste et détecter si "
"une modification concurrente s'est produite durant le temps de réflexion "
"d'un usager. A vérifier en fin de conversation."

#. Tag: para
#, no-c-format
msgid ""
"<emphasis>Detached Objects: if you decide to use the "
"<emphasis>session-per-request pattern, all loaded instances will "
"be in the detached state during user think time. Hibernate allows you to "
"reattach the objects and persist the modifications. The pattern is called "
"<emphasis>session-per-request-with-detached-objects. Automatic "
"versioning is used to isolate concurrent modifications."
msgstr ""
"<emphasis>Objets Détachés - Si vous décidez d'utiliser le "
"paradigme <emphasis>session-par-requête discuté plus haut, toutes "
"les entités chargées en mémoire deviendront des objets détachés durant le "
"temps de réflexion de l'usager. Hibernate vous permet de rattacher ces "
"objets et de persister les modifications y ayant été apportées. Ce pattern "
"est appelé: <emphasis>session-per- request-with-detached-objects "
"(littéralement: session- par-requête-avec-objets-détachés). Le versionnage "
"automatique est utilisé afin d'isoler les modifications concurrentes. "

#. Tag: para
#, no-c-format
msgid ""
"<emphasis>Extended (or Long) Session: the Hibernate "
"<literal>Session can be disconnected from the underlying JDBC "
"connection after the database transaction has been committed and reconnected "
"when a new client request occurs. This pattern is known as <emphasis>session-"
"per-conversation</emphasis> and makes even reattachment unnecessary. "
"Automatic versioning is used to isolate concurrent modifications and the "
"<literal>Session will not be allowed to be flushed automatically, "
"but explicitly."
msgstr ""
"<emphasis>Session Longues (conversation) - Une Session (Littéralement: session-par- "
"conversation) et rend superflu le rattachement des objets. Le versionnage "
"automatique est utilisé afin d'isoler les modifications concurrentes. "

#. Tag: para
#, no-c-format
msgid ""
"Both <emphasis>session-per-request-with-detached-objects and "
"<emphasis>session-per-conversation have advantages and "
"disadvantages. These disadvantages are discussed later in this chapter in "
"the context of optimistic concurrency control."
msgstr ""
"Les deux patterns <emphasis>session-per-request-with- detached- objectssession-"
"per-conversation</emphasis> (session-par-conversation) ont chacun leurs "
"avantages et désavantages qui seront exposés dans ce même chapitre, dans la "
"section au sujet du contrôle optimiste de concurrence. "

#. Tag: title
#, no-c-format
msgid "Considering object identity"
msgstr "L'identité des objets"

#. Tag: para
#, no-c-format
msgid ""
"An application can concurrently access the same persistent state in two "
"different <literal>Sessions. However, an instance of a persistent "
"class is never shared between two <literal>Session instances. It "
"is for this reason that there are two different notions of identity:"
msgstr ""
"Une application peut accéder à la même entité persistante de manière "
"concurrente dans deux <literal>Session s différentes. Toutefois, "
"une instance d'une classe persistante n'est jamais partagée par deux "
"instances distinctes de la classe <literal>Session. Il existe donc "
"deux notions de l'identité d'un objet :"

#. Tag: term
#, no-c-format
msgid "Database Identity"
msgstr "Identité de database"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>foo.getId().equals( bar.getId() )"
msgstr "<literal>foo.getId().equals( bar.getId() )"

#. Tag: term
#, no-c-format
msgid "JVM Identity"
msgstr "Identité JVM"

#. Tag: para
#, no-c-format
msgid "<literal>foo==bar"
msgstr "<literal>foo==bar"

#. Tag: para
#, no-c-format
msgid ""
"For objects attached to a <emphasis>particular SessionSession), the two "
"notions are equivalent and JVM identity for database identity is guaranteed "
"by Hibernate. While the application might concurrently access the \"same"
"\" (persistent identity) business object in two different sessions, the two "
"instances will actually be \"different\" (JVM identity). Conflicts are "
"resolved using an optimistic approach and automatic versioning at flush/"
"commit time."
msgstr ""
"Ainsi, pour des objets attachés à une <literal>Sessionparticulière (c'est-à-dire dans la portée d'une "
"instance de <literal>Session), ces deux notions d'identité sont "
"équivalentes et l'identité JVM pour l'identité de la base de données sont  "
"garanties par Hibernate. Cependant, alors qu'une application peut accéder de "
"manière concurrente au \"même\" objet métier (identité persistante) dans "
"deux sessions différentes, les deux instances seront en fait \"différentes"
"\" (en ce qui a trait à l'identité JVM). Les conflits sont résolus "
"automatiquement par approche optimiste grâce au système de versionnage "
"automatique au moment du flush/sauvegarde. "

#. Tag: para
#, no-c-format
msgid ""
"This approach leaves Hibernate and the database to worry about concurrency. "
"It also provides the best scalability, since guaranteeing identity in single-"
"threaded units of work means that it does not need expensive locking or "
"other means of synchronization. The application does not need to synchronize "
"on any business object, as long as it maintains a single thread per "
"<literal>Session. Within a Session the "
"application can safely use <literal>== to compare objects."
msgstr ""
"Cette approche permet de reléguer à Hibernate et à la base de données sous-"
"jacente le soin de gérer les problèmes d'accès concurrents. Cette manière de "
"faire assure également une meilleure extensibilité de l'application puisque "
"assurer l'identité JVM dans un thread ne nécessite pas de mécanismes de "
"verrouillage coûteux ou d'autres dispositifs de synchronisation. Une "
"application n'aura jamais besoin de synchroniser des objets d'affaire tant "
"qu'elle peut garantir qu'un seul thread aura accès à une instance de "
"<literal>Session . Dans le cadre d'exécution d'un objet "
"<literal>Session, l'application peut utiliser en toute sécurité "
"<literal>==  pour comparer des objets. "

#. Tag: para
#, no-c-format
msgid ""
"However, an application that uses <literal>== outside of a "
"<literal>Session might produce unexpected results. This might "
"occur even in some unexpected places. For example, if you put two detached "
"instances into the same <literal>Set, both might have the same "
"database identity (i.e., they represent the same row). JVM identity, "
"however, is by definition not guaranteed for instances in a detached state. "
"The developer has to override the <literal>equals() and "
"<literal>hashCode() methods in persistent classes and implement "
"their own notion of object equality. There is one caveat: never use the "
"database identifier to implement equality. Use a business key that is a "
"combination of unique, usually immutable, attributes. The database "
"identifier will change if a transient object is made persistent. If the "
"transient instance (usually together with detached instances) is held in a "
"<literal>Set, changing the hashcode breaks the contract of the "
"<literal>Set. Attributes for business keys do not have to be as "
"stable as database primary keys; you only have to guarantee stability as "
"long as the objects are in the same <literal>Set. See the "
"Hibernate website for a more thorough discussion of this issue. Please note "
"that this is not a Hibernate issue, but simply how Java object identity and "
"equality has to be implemented."
msgstr ""
"Une application qui utiliserait <literal>== à l'extérieur du cadre "
"d'exécution d'une <literal>Session pourrait obtenir des résultats "
"inattendus. Par exemple, si vous mettez deux objets dans le même "
"<literal>Set , ceux-ci pourraient avoir la même identité de base "
"de données (c'est-à-dire ils représentent le même enregistrement), mais leur "
"identité JVM pourrait être différente (elle ne peut, par définition, pas "
"être garantie sur deux objets détachés). Le développeur doit donc redéfinir "
"l'implémentation des méthodes <literal>equals() et "
"<literal>hashcode() dans les classes persistantes et y adjoindre "
"sa propre notion d'identité. Il existe toutefois une restriction : il ne "
"faut jamais utiliser uniquement l'identifiant de la base de données dans "
"l'implémentation de l'égalité; il faut utiliser une clé d'affaire, "
"généralement une combinaison de plusieurs attributs uniques, si possible "
"immuables. Les identifiants de base de données vont changer si un objet "
"transitoire (transient) devient persistant. Si une instance transitoire (en "
"général avec des instances dégachées) est contenue dans un <literal>SetSet . "
"Les attributs pour les clés d'affaire n'ont pas à être aussi stables que des "
"clés primaires de bases de données. Il suffit simplement qu'elles soient "
"stables tant et aussi longtemps que les objets sont dans le même "
"<literal>Set . Veuillez consulter le site web Hibernate pour des "
"discussions plus pointues à ce sujet. Notez que ce concept n'est pas propre "
"à Hibernate mais bien général à l'implémentation de l'identité et de "
"l'égalité en Java. "

#. Tag: title
#, no-c-format
msgid "Common issues"
msgstr "Problèmes communs"

#. Tag: para
#, no-c-format
msgid ""
"Do not use the anti-patterns <emphasis>session-per-user-session "
"or <emphasis>session-per-application (there are, however, rare "
"exceptions to this rule). Some of the following issues might also arise "
"within the recommended patterns, so ensure that you understand the "
"implications before making a design decision:"
msgstr ""
"Bien qu'il puisse y avoir quelques rares exceptions à cette règle, il est "
"recommandé de ne jamais utiliser les anti-modèles <emphasis>session-par- "
"utilisateur-session</emphasis> ou session-par-application is not thread-safe. Things that work "
"concurrently, like HTTP requests, session beans, or Swing workers, will "
"cause race conditions if a <literal>Session instance is shared. If "
"you keep your Hibernate <literal>Session in your "
"<literal>HttpSession (this is discussed later in the chapter), you "
"should consider synchronizing access to your Http session. Otherwise, a user "
"that clicks reload fast enough can use the same <literal>Session "
"in two concurrently running threads."
msgstr ""
"L'objet <literal>Session n'est pas conçu pour être utilisé par de "
"multiples threads. En conséquence, les objets potentiellement multi-thread "
"comme les requêtes HTTP, les EJB Session et Swing Worker, risquent de "
"provoquer des conditions de course dans la <literal>Session si "
"celle-ci est partagée. Si vous gardez votre <literal>Session "
"Hibernate dans la <literal>HttpSession (le sujet sera traité "
"ultérieurement), il serait préférable de synchroniser les accès à la session "
"Http afin d'éviter qu'un usager ne recharge une page assez rapidement pour "
"que deux requêtes exécutant dans des threads concurrents n'utilisent la même "
"<literal>Session."

#. Tag: para
#, no-c-format
msgid ""
"An exception thrown by Hibernate means you have to rollback your database "
"transaction and close the <literal>Session immediately (this is "
"discussed in more detail later in the chapter). If your <literal>Session est liée à l'application, il faut arrêter "
"l'application. Le rollback de la transaction de base de données ne remettra "
"pas les objets dans leur état du début de la transaction. Ainsi, cela "
"signifie que l'état de la base de données et les objets d'affaires "
"pourraient être désynchronisés d'avec les enregistrements. Généralement, "
"cela ne cause pas de réel problème puisque la plupart des exceptions sont "
"non traitables et de toutes façons, vous devez recommencer le processus "
"après le rollback). "

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>Session caches every object that is in a persistent "
"state (watched and checked for dirty state by Hibernate). If you keep it "
"open for a long time or simply load too much data, it will grow endlessly "
"until you get an OutOfMemoryException. One solution is to call <literal>clear"
"()</literal> and evict() to manage the Session open for the duration of a user session "
"also means a higher probability of stale data."
msgstr ""
"La <literal>Session met en mémoire cache tous les objets "
"persistants (les objets surveillés et dont l'état (dirty) est vérifié par "
"Hibernate.) Si la <literal>Session est ouverte indéfiniment ou si "
"une trop grande quantité d'objets y est chargée, l'utilisation de la mémoire "
"peut potentiellement croître jusqu'à atteindre java.lang.OutOfMemoryError, "
"le maximum alouable à l'application. Une solution à ce problème est "
"d'appeler les méthodes <literal>Session.clear() et "
"<literal>Session.evict() pour gérer la mémoire cache de la "
"<literal>Session. Vous pouvez également utiliser des procédures "
"stockées si vous devez lancer des traitements sur de grandes quantités "
"d'informations. Certaines solutions sont décrites ici : <xref linkend=\"batch"
"\" />. Garder une <literal>Session ouverte pour toute la durée "
"d'une session usager, augmente également considérablement le risque de "
"travailler avec des informations périmées. "

#. Tag: title
#, no-c-format
msgid "Database transaction demarcation"
msgstr "Démarcation des transactions de base de données"

#. Tag: para
#, no-c-format
msgid ""
"Database, or system, transaction boundaries are always necessary. No "
"communication with the database can occur outside of a database transaction "
"(this seems to confuse many developers who are used to the auto-commit "
"mode). Always use clear transaction boundaries, even for read-only "
"operations. Depending on your isolation level and database capabilities this "
"might not be required, but there is no downside if you always demarcate "
"transactions explicitly. Certainly, a single database transaction is going "
"to perform better than many small transactions, even for reading data."
msgstr ""
"La démarcation des transactions de base de données (ou système) est toujours "
"nécessaire. Aucune communication avec la base de données ne peut être "
"effectuée à l'extérieur du cadre d'une transaction. (Il semble que ce "
"concept soit mal compris par plusieurs développeurs trop habitués à utiliser "
"le mode auto-commit.) Utilisez toujours la démarcation des des transactions, "
"même pour des opérations en lecture seule. Certains niveaux d'isolation et "
"certaines possibilités offertes par les bases de données permettent de "
"l'éviter, il n'est jamais désavantageux de toujours explicitement indiquer "
"les bornes de transaction. Il est certain qu'une transaction unique de base "
"de données sera plus performante que de nombreuses petites transactions, "
"même pour les opérations simples de lecture. "

#. Tag: para
#, no-c-format
msgid ""
"A Hibernate application can run in non-managed (i.e., standalone, simple "
"Web- or Swing applications) and managed J2EE environments. In a non-managed "
"environment, Hibernate is usually responsible for its own database "
"connection pool. The application developer has to manually set transaction "
"boundaries (begin, commit, or rollback database transactions) themselves. A "
"managed environment usually provides container-managed transactions (CMT), "
"with the transaction assembly defined declaratively (in deployment "
"descriptors of EJB session beans, for example). Programmatic transaction "
"demarcation is then no longer necessary."
msgstr ""
"Une application utilisant Hibernate peut s'exécuter dans un environnement "
"léger n'offrant pas la gestion automatique des transactions (application "
"autonome, application web simple ou applications Swing) ou dans un "
"environnement J2EE offrant des services de gestion automatiques des "
"transactions JTA. Dans un environnement simple, Hibernate a généralement la "
"responsabilité de la gestion de son propre pool de connexions à la base de "
"données. Le développeur de l'application doit manuellement délimiter les "
"transactions. En d'autres mots, il appartient au développeur de gérer les "
"appels à <literal>Transaction.begin() , Transaction.commit"
"()</literal> et Transaction.rollback(). Un environnement "
"transactionnel J2EE (serveur d'application J2EE) doit offrir la gestion des "
"transactions au niveau du conteneur J2EE. Les bornes de transaction peuvent "
"normalement être définies de manière déclarative dans les descripteurs de "
"déploiement d'EJB Session, par exemple. La gestion programmatique des "
"transactions n'y est donc plus nécessaire."

#. Tag: para
#, no-c-format
msgid ""
"However, it is often desirable to keep your persistence layer portable "
"between non-managed resource-local environments, and systems that can rely "
"on JTA but use BMT instead of CMT. In both cases use programmatic "
"transaction demarcation. Hibernate offers a wrapper API called "
"<literal>Transaction that translates into the native transaction "
"system of your deployment environment. This API is actually optional, but we "
"strongly encourage its use unless you are in a CMT session bean."
msgstr ""
"Cependant, il est souvent préférable d'avoir une couche de persistance "
"portable entre les environnements non gérés de ressources locales et les "
"systèmes qui s'appuient sur JTA mais utilisent BMT à la place de CMT. Dans "
"les deux cas, vous utiliserez la démarcation de transaction programmatique. "
"Hibernate offre donc une API appelée <literal>Transaction qui sert "
"d'enveloppe pour le système de transaction natif de l'environnement de "
"déploiement. Il n'est pas obligatoire d'utiliser cette API, mais il est "
"fortement conseillé de le faire, sauf lors de l'utilisation de CMT Session "
"Bean."

#. Tag: para
#, no-c-format
msgid ""
"Ending a <literal>Session usually involves four distinct phases:"
msgstr ""
"Il existe quatre étapes distinctes lors de la fermeture d'une "
"<literal>Session :"

#. Tag: para
#, no-c-format
msgid "flush the session"
msgstr "flush de la session"

#. Tag: para
#, no-c-format
msgid "commit the transaction"
msgstr "commit de la transaction"

#. Tag: para
#, no-c-format
msgid "close the session"
msgstr "fermeture de la session "

#. Tag: para
#, no-c-format
msgid "handle exceptions"
msgstr "gestion des exceptions"

#. Tag: para
#, no-c-format
msgid ""
"We discussed Flushing the session earlier, so we will now have a closer look "
"at transaction demarcation and exception handling in both managed and non-"
"managed environments."
msgstr ""
"La notion de \"Flushing\" a déjà été expliquée, nous abordons maintenant la "
"démarcation des transactions et la gestion des exceptions dans les "
"environnements gérés et non-gérés."

#. Tag: title
#, no-c-format
msgid "Non-managed environment"
msgstr "Environnement non gérés"

#. Tag: para
#, no-c-format
msgid ""
"If a Hibernate persistence layer runs in a non-managed environment, database "
"connections are usually handled by simple (i.e., non-DataSource) connection "
"pools from which Hibernate obtains connections as needed. The session/"
"transaction handling idiom looks like this:"
msgstr ""
"Si la couche de persistance Hibernate s'exécute dans un environnement non "
"géré, les connexions à la base de données seront généralement prises en "
"charge par le mécanisme de pool d'Hibernate qui obtient les connexions. La "
"gestion de la session et de la transaction se fera donc de la manière "
"suivante : "

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You do not have to <literal>flush() the Session "
"explicitly: the call to <literal>commit() automatically triggers "
"the synchronization depending on the <link linkend=\"objectstate-flushing"
"\">FlushMode</link> for the session. A call to close() "
"marks the end of a session. The main implication of <literal>close() explicitement sur la "
"<literal>Session - l'appel de commit() "
"déclenchera automatiquement la synchronisation (selon le FlushMode <xref "
"linkend=\"objectstate-flushing\" /> de la session. Un appel à <literal>close"
"()</literal> marque la fin de la session. La conséquence directe de "
"<literal>close() est que la connexion à la base de données sera "
"relâchée par la session. Ce code est portable et fonctionne dans les "
"environnements non gérés et les environnements JTA. "

#. Tag: para
#, no-c-format
msgid ""
"As outlined earlier, a much more flexible solution is Hibernate's built-in "
"\"current session\" context management:"
msgstr ""
"Une solution plus flexible est la gestion par contexte de la session "
"courante intégrée, fournie par Hibernate que nous avons déjà rencontrée :"

#. Tag: para
#, no-c-format
msgid ""
"You will not see these code snippets in a regular application; fatal "
"(system) exceptions should always be caught at the \"top\". In other words, "
"the code that executes Hibernate calls in the persistence layer, and the "
"code that handles <literal>RuntimeException (and usually can only "
"clean up and exit), are in different layers. The current context management "
"by Hibernate can significantly simplify this design by accessing a "
"<literal>SessionFactory. Exception handling is discussed later in "
"this chapter."
msgstr ""
"Vous ne verrez probablement jamais ces exemples de code dans les "
"applications ; les exceptions fatales (exceptions du système) ne devraient "
"être traitées que dans la couche la plus \"haute\". En d'autres termes, le "
"code qui exécute les appels à Hibernate (à la couche de persistance) et le "
"code qui gère les <literal>RuntimeException (qui ne peut "
"généralement effectuer qu'un nettoyage et une sortie) sont dans des couches "
"différentes. La gestion du contexte courant par Hibernate peut simplifier "
"notablement ce design, puisqu'il vous suffit d'accéder à la "
"<literal>SessionFactory. La gestion des exceptions est traitée "
"plus loin dans ce chapitre. "

#. Tag: para
#, no-c-format
msgid ""
"You should select <literal>org.hibernate.transaction.JDBCTransactionFactory"
"\"thread\"</literal> as your hibernate."
"current_session_context_class</literal>."
msgstr ""
"Notez que vous devriez sélectionner <literal>org.hibernate.transaction."
"JDBCTransactionFactory</literal> (le défaut), pour le second exemple "
"<literal>\"thread\" comme votre hibernate."
"current_session_context_class</literal>. "

#. Tag: title
#, no-c-format
msgid "Using JTA"
msgstr "Utilisation de JTA"

#. Tag: para
#, no-c-format
msgid ""
"If your persistence layer runs in an application server (for example, behind "
"EJB session beans), every datasource connection obtained by Hibernate will "
"automatically be part of the global JTA transaction. You can also install a "
"standalone JTA implementation and use it without EJB. Hibernate offers two "
"strategies for JTA integration."
msgstr ""
"Si votre couche de persistance s'exécute dans un serveur d'applications (par "
"exemple, derrière un EJB Session Bean), toutes les datasources utilisées par "
"Hibernate feront automatiquement partie de transactions JTA globales. Vous "
"pouvez également installer une implémentation autonome JTA et l'utiliser "
"sans l'EJB.Hibernate propose deux stratégies pour réussir l'intégration JTA. "

#. Tag: para
#, no-c-format
msgid ""
"If you use bean-managed transactions (BMT), Hibernate will tell the "
"application server to start and end a BMT transaction if you use the "
"<literal>Transaction API. The transaction management code is "
"identical to the non-managed environment."
msgstr ""
"Si vous utilisez des transactions gérées par un EJB (bean managed "
"transactions - BMT), Hibernate informera le serveur d'applications du début "
"et de la fin des transactions si vous utilisez l'API <literal>Transaction, that is, "
"the <literal>getCurrentSession() functionality for easy context "
"propagation, use the JTA <literal>UserTransaction API directly:"
msgstr ""
"Si vous souhaitez utiliser une <literal>Session couplée à la "
"transaction, c'est à dire, utiliser la fonctionnalité "
"<literal>getCurrentSession() pour la propagation facile du "
"contexte, vous devez utiliser l'API JTA <literal>UserTransaction "
"directement :"

#. Tag: para
#, no-c-format
msgid ""
"With CMT, transaction demarcation is completed in session bean deployment "
"descriptors, not programmatically. The code is reduced to:"
msgstr ""
"Avec CMT, la démarcation des transactions est faite dans les descripteurs de "
"déploiement des Beans Sessions et non de manière programmatique, par "
"conséquent le code est réduit à : "

#. Tag: para
#, no-c-format
msgid ""
"In a CMT/EJB, even rollback happens automatically. An unhandled "
"<literal>RuntimeException thrown by a session bean method tells "
"the container to set the global transaction to rollback. <emphasis>You do "
"not need to use the Hibernate <literal>Transaction API at all with "
"BMT or CMT, and you get automatic propagation of the \"current\" Session "
"bound to the transaction.</emphasis>"
msgstr ""
"Dans un EJB CMT, le rollback aussi intervient automatiquement, puisqu'une "
"<literal>RuntimeException non traitée et soulevée par une méthode "
"d'un bean session indique au conteneur d'annuler la transaction globale. "
"<emphasis>Ceci veut donc dire que vous n'avez pas à utiliser l'API "
"<literal>Transaction de Hibernate dans CMT ou BMT et vous obtenez "
"la propagation automatique de la session courante liée à la transaction.</"
"emphasis>"

#. Tag: para
#, no-c-format
msgid ""
"When configuring Hibernate's transaction factory, choose <literal>org."
"hibernate.transaction.JTATransactionFactory</literal> if you use JTA "
"directly (BMT), and <literal>org.hibernate.transaction."
"CMTTransactionFactory</literal> in a CMT session bean. Remember to also set "
"<literal>hibernate.transaction.manager_lookup_class. Ensure that "
"your <literal>hibernate.current_session_context_class is either "
"unset (backwards compatibility), or is set to <literal>\"jta\"."
msgstr ""
"Notez que le fichier de configuration Hibernate devrait contenir les valeurs "
"<literal>org.hibernate.transaction.JTATransactionFactory dans un "
"environnement BMT ou <literal>org.hibernate.transaction."
"CMTTransactionFactory</literal> dans un environnement CMT là où vous "
"configurez votre fabrique de transaction Hibernate. N'oubliez pas non plus "
"de spécifier le paramètre <literal>org.hibernate.transaction."
"manager_lookup_class</literal> . De plus, assurez vous de fixer votre "
"<literal>hibernate.current_session_context_class soit à "
"\"jta\"</literal> ou de ne pas le configurer (compatibilité avec les "
"versions précédentes). "

#. Tag: para
#, no-c-format
msgid ""
"The <literal>getCurrentSession() operation has one downside in a "
"JTA environment. There is one caveat to the use of <literal>after_statement or "
"<literal>Iterator instances returned by scroll()iterate(). You must "
"release the underlying database cursor by calling <literal>ScrollableResults."
"close()</literal> or Hibernate.close(Iterator) explicitly "
"from a <literal>finally block. Most applications can easily avoid "
"using <literal>scroll() or iterate() from the "
"JTA or CMT code.)"
msgstr ""
"La méthode <literal>getCurrentSession() a un inconvénient dans les "
"environnements JTA. Il y a une astuce qui est d'utiliser un mode de "
"libération de connexion <literal>after_statement , qui est alors "
"utilisé par défaut. Du à une étrange limitation de la spec JTA, il n'est pas "
"possible à Hibernate de nettoyer automatiquement un "
"<literal>ScrollableResults ouvert ou une instance "
"d'<literal>Iterator retournés scroll() ou "
"<literal>iterate(). Vous devez libérer le "
"curseur base de données sous jacent ou invoquer <literal>Hibernate.close"
"(Iterator)</literal> explicitement depuis un bloc finally ou iterate() dans un code JTA "
"ou CMT.) "

#. Tag: title
#, no-c-format
msgid "Exception handling"
msgstr "Gestion des exceptions"

#. Tag: para
#, no-c-format
msgid ""
"If the <literal>Session throws an exception, including any "
"<literal>SQLException, immediately rollback the database "
"transaction, call <literal>Session.close() and discard the "
"<literal>Session instance. Certain methods of Sessionnot leave the session in a consistent "
"state. No exception thrown by Hibernate can be treated as recoverable. "
"Ensure that the <literal>Session will be closed by calling "
"<literal>close() in a finally block."
msgstr ""
"Si une <literal>Session lance une exception (incluant les "
"exceptions du type <literal>SQLException ou d'un sous-type), vous "
"devez immédiatement effectuer le rollback de la transaction, appeler "
"<literal>Session.close() et relâcher les références sur l'objet "
"<literal>Session . La Session contient des "
"méthodes pouvant la mettre dans un état inutilisable. Vous devez considérer "
"qu'<emphasis>aucune exception lancée par Hibernate n'est "
"traitable comme recouvrable. Assurez-vous de fermer la session en appelant "
"<literal>close() dans un bloc finally . "

#. Tag: para
#, no-c-format
msgid ""
"The <literal>HibernateException, which wraps most of the errors "
"that can occur in a Hibernate persistence layer, is an unchecked exception. "
"It was not in older versions of Hibernate. In our opinion, we should not "
"force the application developer to catch an unrecoverable exception at a low "
"layer. In most systems, unchecked and fatal exceptions are handled in one of "
"the first frames of the method call stack (i.e., in higher layers) and "
"either an error message is presented to the application user or some other "
"appropriate action is taken. Note that Hibernate might also throw other "
"unchecked exceptions that are not a <literal>HibernateException. "
"These are not recoverable and appropriate action should be taken."
msgstr ""
"L'exception <literal>HibernateException, qui englobe la plupart "
"des exceptions pouvant survenir dans la couche de persistance Hibernate, est "
"une exception non vérifiée (Ceci n'était pas le cas dans des versions "
"antérieures de Hibernate.) Nous pensons que nous ne devrions pas forcer un "
"développeur à gérer une exception qu'il ne peut de toute façon pas traiter "
"dans une couche technique. Dans la plupart des systèmes, les exceptions non "
"vérifiées et les exceptions fatales sont gérées en amont du processus (dans "
"les couches hautes) et un message d'erreur est alors affiché à l'usager (ou "
"un traitement alternatif est invoqué.) Veuillez noter que Hibernate peut "
"également lancer des exceptions non vérifiées d'un autre type que "
"<literal>HibernateException. Celles-ci sont également non "
"traitables et vous devez les traiter comme telles. "

#. Tag: para
#, no-c-format
msgid ""
"Hibernate wraps <literal>SQLExceptions thrown while interacting "
"with the database in a <literal>JDBCException. In fact, Hibernate "
"will attempt to convert the exception into a more meaningful subclass of "
"<literal>JDBCException. The underlying SQLExceptionJDBCException.getCause()SQLException into an "
"appropriate <literal>JDBCException subclass using the "
"<literal>SQLExceptionConverter attached to the "
"<literal>SessionFactory. By default, the "
"<literal>SQLExceptionConverter is defined by the configured "
"dialect. However, it is also possible to plug in a custom implementation. "
"See the javadocs for the <literal>SQLExceptionConverterFactory "
"class for details. The standard <literal>JDBCException subtypes "
"are:"
msgstr ""
"Hibernate englobe les <literal>SQLException s lancées lors des "
"interactions directes avec la base de données dans des exceptions de type: "
"<literal>JDBCException. En fait, Hibernate essaiera de convertir "
"l'exception dans un sous-type plus significatif de <literal>JDBCExceptionSQLException sous-jacente est "
"toujours disponible via la méthode <literal>JDBCException.getCause()SQLExceptionConverter en "
"une sous-classe <literal>JDBCException, en utilisant le "
"<literal>SQLExceptionConverter qui est rattaché à l'objet "
"<literal>SessionFactory. Par défaut, le "
"<literal>SQLExceptionConverter est défini par le dialecte "
"configuré dans Hibernate. Toutefois, il est possible de fournir sa propre "
"implémentation de l'interface. (Veuillez vous référer à la javadoc sur la "
"classe <literal>SQLExceptionConverterFactory pour plus de détails. "
"Les sous-types standard de <literal>JDBCException sont :"

#. Tag: para
#, no-c-format
msgid ""
"<literal>JDBCConnectionException: indicates an error with the "
"underlying JDBC communication."
msgstr ""
"<literal>JDBCConnectionException - indique une erreur de "
"communication avec la couche JDBC sous-jacente. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>SQLGrammarException: indicates a grammar or syntax "
"problem with the issued SQL."
msgstr ""
"<literal>SQLGrammarException - indique un problème de grammaire ou "
"de syntaxe avec la requête SQL envoyée. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>ConstraintViolationException: indicates some form of "
"integrity constraint violation."
msgstr ""
"<literal>ConstraintViolationException - indique une violation de "
"contrainte d'intégrité. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>LockAcquisitionException: indicates an error acquiring a "
"lock level necessary to perform the requested operation."
msgstr ""
"<literal>LockAcquisitionException - indique une erreur de "
"verrouillage lors de l'exécution de la requête. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>GenericJDBCException: a generic exception which did not "
"fall into any of the other categories."
msgstr ""
"<literal>GenericJDBCException - indique une erreur générique ne "
"correspondant à aucune autre catégorie. "

#. Tag: title
#, no-c-format
msgid "Transaction timeout"
msgstr "Timeout de transaction"

#. Tag: para
#, no-c-format
msgid ""
"An important feature provided by a managed environment like EJB, that is "
"never provided for non-managed code, is transaction timeout. Transaction "
"timeouts ensure that no misbehaving transaction can indefinitely tie up "
"resources while returning no response to the user. Outside a managed (JTA) "
"environment, Hibernate cannot fully provide this functionality. However, "
"Hibernate can at least control data access operations, ensuring that "
"database level deadlocks and queries with huge result sets are limited by a "
"defined timeout. In a managed environment, Hibernate can delegate "
"transaction timeout to JTA. This functionality is abstracted by the "
"Hibernate <literal>Transaction object."
msgstr ""
"Une des caractéristiques extrêmement importante fournie dans les "
"environnements gérés tels les EJB, est la gestion du timeout de transaction "
"qui n'est jamais fournie pour le code non géré. La gestion des dépassements "
"de temps de transaction vise à s'assurer qu'une transaction agissant "
"incorrectement ne viendra pas bloquer indéfiniment les ressources de "
"l'application et ne retourner aucune réponse à l'utilisateur. Hibernate ne "
"peut fournir cette fonctionnalité dans un environnement transactionnel non-"
"JTA. Par contre, Hibernate gère les opérations d'accès aux données en "
"allouant un temps maximal aux requêtes pour s'exécuter. Ainsi, une requête "
"créant de l'inter blocage ou retournant de très grandes quantités "
"d'informations pourrait être interrompue. Dans un environnement géré, "
"Hibernate peut déléguer au gestionnaire de transaction JTA, le soin de gérer "
"les dépassements de temps. Cette fonctionnalité est abstraite par l'objet "
"<literal>Transaction."

#. Tag: para
#, no-c-format
msgid ""
"<literal>setTimeout() cannot be called in a CMT bean, where "
"transaction timeouts must be defined declaratively."
msgstr ""
"Notez que <literal>setTimeout() ne peut pas être appelé d'un EJB "
"CMT, puisque le timeout des transaction doit être spécifié de manière "
"déclarative. "

#. Tag: title
#, no-c-format
msgid "Optimistic concurrency control"
msgstr "Contrôle de concurrence optimiste"

#. Tag: para
#, no-c-format
msgid ""
"The only approach that is consistent with high concurrency and high "
"scalability, is optimistic concurrency control with versioning. Version "
"checking uses version numbers, or timestamps, to detect conflicting updates "
"and to prevent lost updates. Hibernate provides three possible approaches to "
"writing application code that uses optimistic concurrency. The use cases we "
"discuss are in the context of long conversations, but version checking also "
"has the benefit of preventing lost updates in single database transactions."
msgstr ""
"La gestion optimiste des accès concurrents avec versionnage est la seule "
"approche pouvant garantir l'extensibilité des applications à haut niveau de "
"charge. Le système de versionnage utilise des numéros de version ou "
"l'horodatage pour détecter les mise à jour causant des conflits avec "
"d'autres actualisations antérieures (et pour éviter la perte de mise à "
"jour). Hibernate propose trois approches possibles pour l'écriture de code "
"applicatif utilisant la gestion optimiste d'accès concurrents. Le cas "
"d'utilisation décrit plus bas fait mention de longues conversations, mais le "
"versionnage peut également améliorer la qualité d'une application en "
"prévenant la perte de mise à jour dans les transactions uniques de base de "
"données. "

#. Tag: title
#, no-c-format
msgid "Application version checking"
msgstr "Vérification du versionnage au niveau applicatif"

#. Tag: para
#, no-c-format
msgid ""
"In an implementation without much help from Hibernate, each interaction with "
"the database occurs in a new <literal>Session and the developer is "
"responsible for reloading all persistent instances from the database before "
"manipulating them. The application is forced to carry out its own version "
"checking to ensure conversation transaction isolation. This approach is the "
"least efficient in terms of database access. It is the approach most similar "
"to entity EJBs."
msgstr ""
"Dans cet exemple d'implémentation utilisant peu les fonctionnalités de "
"Hibernate, chaque interaction avec la base de données se fait en utilisant "
"une nouvelle <literal>Session et le développeur doit recharger les "
"données persistantes à partir de la base de données avant de les manipuler. "
"Cette implémentation force l'application à vérifier la version des objets "
"afin de maintenir l'isolation transactionnelle. Cette approche, semblable à "
"celle retrouvée pour les EJB, est la moins efficace parmi celles qui sont "
"présentées dans ce chapitre. "

#. Tag: para
#, no-c-format
msgid ""
"The <literal>version property is mapped using <"
"version></literal>, and Hibernate will automatically increment it during "
"flush if the entity is dirty."
msgstr ""
"Le mappage de la propriété <literal>version est fait via "
"<literal><version> et Hibernate l'incrémentera "
"automatiquement à chaque flush() si l'entité doit être mise à jour."

#. Tag: para
#, no-c-format
msgid ""
"If you are operating in a low-data-concurrency environment, and do not "
"require version checking, you can use this approach and skip the version "
"check. In this case, <emphasis>last commit wins is the default "
"strategy for long conversations. Be aware that this might confuse the users "
"of the application, as they might experience lost updates without error "
"messages or a chance to merge conflicting changes."
msgstr ""
"Bien sûr, si votre application ne fait pas face à beaucoup d'accès "
"concurrents et ne nécessite pas l'utilisation du versionnage, cette approche "
"peut également être utilisée, il n'y a qu'à ignorer le code relié au "
"versionnage. Dans ce cas, la stratégie du <emphasis>last commit wins longue, soit des instances "
"détachées comme paradigme des conversations. "

#. Tag: title
#, no-c-format
msgid "Extended session and automatic versioning"
msgstr "Les sessions longues et le versionnage automatique."

#. Tag: para
#, no-c-format
msgid ""
"A single <literal>Session instance and its persistent instances "
"that are used for the whole conversation are known as <emphasis>session-per-"
"conversation</emphasis>. Hibernate checks instance versions at flush time, "
"throwing an exception if concurrent modification is detected. It is up to "
"the developer to catch and handle this exception. Common options are the "
"opportunity for the user to merge changes or to restart the business "
"conversation with non-stale data."
msgstr ""
"Dans ce scénario, une seule instance de <literal>Session et des "
"objets persistants est utilisée pour toute la conversation, connue sous "
"<emphasis>session-par-conversation. Hibernate vérifie la version "
"des objets persistants avant d'effectuer le flush() et lance une exception "
"si une modification concurrente est détectée. Il appartient alors au "
"développeur de gérer l'exception. Les traitements alternatifs généralement "
"proposés sont alors de permettre à l'usager de faire la fusion des données "
"ou de lui offrir de recommencer son travail à partie des données les plus "
"récentes dans la base de données. "

#. Tag: para
#, no-c-format
msgid ""
"The <literal>Session is disconnected from any underlying JDBC "
"connection when waiting for user interaction. This approach is the most "
"efficient in terms of database access. The application does not version "
"check or reattach detached instances, nor does it have to reload instances "
"in every database transaction."
msgstr ""
"Notez que lorsqu'une application est en attente d'une action de la part de "
"l'usager, la <literal>Session n'est pas connectée à la couche JDBC "
"sous-jacente. C'est la manière la plus efficace de gérer les accès à la base "
"de données. L'application ne devrait pas se préoccuper du versionnage des "
"objets, ou du rattachement des objets détachés, ni du rechargement de tous "
"les objets à chaque transaction. "

#. Tag: para
#, no-c-format
msgid ""
"The <literal>foo object knows which Session it "
"was loaded in. Beginning a new database transaction on an old session "
"obtains a new connection and resumes the session. Committing a database "
"transaction disconnects a session from the JDBC connection and returns the "
"connection to the pool. After reconnection, to force a version check on data "
"you are not updating, you can call <literal>Session.lock() with "
"<literal>LockMode.READ on any objects that might have been updated "
"by another transaction. You do not need to lock any data that you "
"<emphasis>are updating. Usually you would set FlushMode."
"MANUAL</literal> on an extended Session, so that only the "
"last database transaction cycle is allowed to actually persist all "
"modifications made in this conversation. Only this last database transaction "
"will include the <literal>flush() operation, and then "
"<literal>close() the session to end the conversation."
msgstr ""
"L'objet <literal>foo sait quel objet Session "
"l'a chargé. <literal>Session.reconnect() obtient une nouvelle "
"connexion (celle-ci peut être également fournie) et permet à la session de "
"continuer son travail. La méthode <literal>Session.disconnect() "
"déconnecte la session de la connexion JDBC et retourne celle-ci au pool de "
"connexion (à moins que vous ne lui ayez fourni vous même la connexion.) "
"Après la reconnexion, afin de forcer la vérification du versionnage de "
"certaines entités que vous ne cherchez pas à actualiser, vous pouvez faire "
"un appel à <literal>Session.lock() en mode LockMode.READ sur "
"une <literal>Session étendue, de façon que seul le dernier cycle "
"de transaction de la base de données puissent persister toutes les "
"modifications effectuées dans cette conversation. Par conséquent, cette "
"dernière transaction inclura l'opération <literal>flush(), de même "
"que <literal>close() la session pour finir la conversation."

#. Tag: para
#, no-c-format
msgid ""
"This pattern is problematic if the <literal>Session is too big to "
"be stored during user think time (for example, an <literal>HttpSessionSession only for a single conversation as it will soon "
"have stale data."
msgstr ""
"Ce modèle peut présenter des problèmes si la <literal>Session est "
"trop volumineuse pour être stockée entre les actions de l'usager. Plus "
"spécifiquement, une session <literal>HttpSession se doit d'être la "
"plus petite possible. Puisque la <literal>Session joue "
"obligatoirement le rôle de mémoire cache de premier niveau et contient à ce "
"titre tous les objets chargés, il est préférable de n'utiliser une "
"<literal>Session que pour une seule conversation, car les objets "
"risquent d'y être rapidement périmés."

#. Tag: title
#, no-c-format
msgid "Note"
msgstr "Remarque"

#. Tag: para
#, no-c-format
msgid ""
"Earlier versions of Hibernate required explicit disconnection and "
"reconnection of a <literal>Session. These methods are deprecated, "
"as beginning and ending a transaction has the same effect."
msgstr ""
"Notez que des versions précédentes de Hibernate exigeaient une déconnexion "
"explicite et une reconnexion d'une <literal>Session. Ces méthodes "
"sont périmées, puisque commencer et terminer une transaction a le même effet."

#. Tag: para
#, no-c-format
msgid ""
"Keep the disconnected <literal>Session close to the persistence "
"layer. Use an EJB stateful session bean to hold the <literal>Session."
msgstr ""
"Notez que la <literal>Session déconnectée devrait être conservée "
"près de la couche de persistance. Autrement dit, utilisez un EJB stateful "
"pour conserver la <literal>Session dans un environnement 3 niveaux "
"et évitez de la sérialiser et de la transférer à la couche de présentation "
"(c'est-à-dire qu'il est préférable de ne pas la conserver dans la session "
"<literal>HttpSession .) "

#. Tag: para
#, no-c-format
msgid ""
"The extended session pattern, or <emphasis>session-per-conversation for this. See the Hibernate Wiki "
"for examples."
msgstr ""
"Le modèle de session étendue, ou <emphasis>session-par-conversation, pour des exemples "
"consultez Hibernate Wiki. "

#. Tag: title
#, no-c-format
msgid "Detached objects and automatic versioning"
msgstr "Les objets détachés et le versionnage automatique"

#. Tag: para
#, no-c-format
msgid ""
"Each interaction with the persistent store occurs in a new <literal>Session "
"and then reattaches them using <literal>Session.update(), "
"<literal>Session.saveOrUpdate(), or Session.merge() . Toutefois, les mêmes instances d'objets "
"persistants sont réutilisées pour chacune de ces interactions. L'application "
"doit pouvoir manipuler l'état des instances détachées ayant été chargées "
"antérieurement via une autre session. Pour ce faire, ces objets persistants "
"doivent être rattachés à la <literal>Session courante en utilisant "
"<literal>Session.update(), Session.saveOrUpdate()Session.merge() ."

#. Tag: para
#, no-c-format
msgid ""
"Again, Hibernate will check instance versions during flush, throwing an "
"exception if conflicting updates occurred."
msgstr ""
"Encore une fois, Hibernate vérifiera la version des instances devant être "
"actualisées durant le flush(). Une exception sera lancée si des conflits "
"sont détectés. "

#. Tag: para
#, no-c-format
msgid ""
"You can also call <literal>lock() instead of update()LockMode.READ (performing a version "
"check and bypassing all caches) if you are sure that the object has not been "
"modified."
msgstr ""
"Vous pouvez également utiliser <literal>lock() au lieu de "
"<literal>update() et utiliser le mode LockMode.READ "
"mapping attribute to <literal>false. Hibernate will then no longer "
"increment versions if the property is dirty."
msgstr ""
"Vous pouvez désactiver l'incrémentation automatique du numéro de version de "
"certains attributs et collections en mettant la valeur du paramètre de "
"mapping <literal>optimistic-lock à false. "
"Hibernate cessera ainsi d'incrémenter leur numéro de version si la propriété "
"est dirty. "

#. Tag: para
#, no-c-format
msgid ""
"Legacy database schemas are often static and cannot be modified. Or, other "
"applications might access the same database and will not know how to handle "
"version numbers or even timestamps. In both cases, versioning cannot rely on "
"a particular column in a table. To force a version check with a comparison "
"of the state of all fields in a row but without a version or timestamp "
"property mapping, turn on <literal>optimistic-lock=\"all\" in the "
"<literal><class> mapping. This conceptually only works if "
"Hibernate can compare the old and the new state (i.e., if you use a single "
"long <literal>Session and not session-per-request-with-detached-"
"objects)."
msgstr ""
"Certaines entreprises possèdent de vieux systèmes dont les schémas de bases "
"de données sont statiques et ne peuvent être modifiés. Il existe aussi des "
"cas où plusieurs applications doivent accéder à la même base de données, "
"mais certaines d'entre elles ne peuvent gérer les numéros de version ou les "
"champs horodatés. Dans les deux cas, le versionnage ne peut se fier à une "
"colonne particulière dans une table. Afin de forcer la vérification de "
"version dans un système sans en faire le mappage, mais en forçant une "
"comparaison des états de tous les attributs d'une entité, vous pouvez "
"utiliser l'attribut <literal>optimistic- lock=\"all\" dans le "
"mappage <literal><class>. Veuillez noter que cette manière "
"de gérer le versionnage ne peut être utilisée que si l'application utilise "
"de longues sessions, lui permettant de comparer l'ancien état et le nouvel "
"état d'une entité. L'utilisation d'un modèle <literal>session-per-request-"
"with-detached- objects</literal> devient alors impossible. "

#. Tag: para
#, no-c-format
msgid ""
"Concurrent modification can be permitted in instances where the changes that "
"have been made do not overlap. If you set <literal>optimistic-lock=\"dirty"
"\"</literal> when mapping the <class>, Hibernate "
"will only compare dirty fields during flush."
msgstr ""
"Il peut être souhaitable de permettre les modifications concurrentes du "
"moment que les modifications ne se chevauchent pas. En configurant la "
"propriété à <literal>optimistic-lock=\"dirty\" quand vous mappez "
"le <literal><class>, Hibernate ne fera la comparaison que "
"des champs devant être actualisés lors du flush."

#. Tag: para
#, no-c-format
msgid ""
"In both cases, with dedicated version/timestamp columns or with a full/dirty "
"field comparison, Hibernate uses a single <literal>UPDATE "
"statement, with an appropriate <literal>WHERE clause, per entity "
"to execute the version check and update the information. If you use "
"transitive persistence to cascade reattachment to associated entities, "
"Hibernate may execute unnecessary updates. This is usually not a problem, "
"but <emphasis>on update triggers in the database might be "
"executed even when no changes have been made to detached instances. You can "
"customize this behavior by setting <literal>select-before-update=\"true\"<class> mapping, forcing Hibernate "
"to <literal>SELECT the instance to ensure that changes did occur "
"before updating the row."
msgstr ""
"Dans les deux cas: en utilisant une colonne de version/horodatée ou via la "
"comparaison de l'état complet de l'objet ou de ses champs modifiés, "
"Hibernate ne créera qu'une seule commande <literal>UPDATE par "
"entité avec la clause <literal>WHERE appropriée pour vérifier la "
"version et mettre à jour les informations. Si vous utilisez la persistance "
"transitive pour propager l'évènement de rattachement à des entités "
"associées, il est possible que Hibernate génère des commandes de mise à jour "
"inutiles. Ceci n'est généralement pas un problème, mais certains "
"déclencheurs <emphasis>on update dans la base de données "
"pourraient être activés même si aucun changement n'était réellement persisté "
"sur des objets détachés. Vous pouvez personnaliser ce comportement en "
"indiquant <literal>select-before- update=\"true\" dans l'élément "
"de mappage <literal><class>. Ceci forcera Hibernate à faire "
"le <literal>SELECT de l'instance afin de s'assurer que l'entité "
"doit réellement être actualisée avant de lancer la commande de mise à jour "
"de l'enregistrement. "

#. Tag: title
#, no-c-format
msgid "Pessimistic locking"
msgstr "Verrouillage pessimiste "

#. Tag: para
#, no-c-format
msgid ""
"It is not intended that users spend much time worrying about locking "
"strategies. It is usually enough to specify an isolation level for the JDBC "
"connections and then simply let the database do all the work. However, "
"advanced users may wish to obtain exclusive pessimistic locks or re-obtain "
"locks at the start of a new transaction."
msgstr ""
"Il n'est nécessaire de s'attarder à la stratégie de verrouillage des entités "
"dans une application utilisant Hibernate. Il est généralement suffisant de "
"définir le niveau d'isolation pour les connexions JDBC et de laisser ensuite "
"la base de donnée effectuer son travail. Toutefois, certains utilisateurs "
"avancés peuvent vouloir obtenir un verrouillage pessimiste exclusif sur un "
"enregistrement, ou le ré-obtenir au lancement d'une nouvelle transaction. "

#. Tag: para
#, no-c-format
msgid ""
"Hibernate will always use the locking mechanism of the database; it never "
"lock objects in memory."
msgstr ""
"Hibernate utilisera toujours le mécanisme de verrouillage de la base de "
"données et ne verrouillera jamais les objets en mémoire."

#. Tag: para
#, no-c-format
msgid ""
"The <literal>LockMode class defines the different lock levels that "
"can be acquired by Hibernate. A lock is obtained by the following mechanisms:"
msgstr ""
"La classe <literal>LockMode définit les différents niveaux de "
"verrouillage pouvant être obtenus par Hibernate. Le verrouillage est obtenu "
"par les mécanismes suivants : "

#. Tag: para
#, no-c-format
msgid ""
"<literal>LockMode.WRITE is acquired automatically when Hibernate "
"updates or inserts a row."
msgstr ""
"<literal>LockMode.WRITE est obtenu automatiquement quand Hibernate "
"actualise ou insère un enregistrement."

#. Tag: para
#, no-c-format
msgid ""
"<literal>LockMode.UPGRADE can be acquired upon explicit user "
"request using <literal>SELECT ... FOR UPDATE on databases which "
"support that syntax."
msgstr ""
"<literal>LockMode.UPGRADE peut être obtenu de manière explicite "
"via la requête en utilisant <literal>SELECT ... FOR UPDATE sur une "
"base de données supportant cette syntaxe. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>LockMode.UPGRADE_NOWAIT can be acquired upon explicit "
"user request using a <literal>SELECT ... FOR UPDATE NOWAIT under "
"Oracle."
msgstr ""
"<literal>LockMode.UPGRADE_NOWAIT peut être obtenu de manière "
"explicite en utilisant <literal>SELECT ... FOR UPDATE NOWAIT sur "
"Oracle. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>LockMode.READ is acquired automatically when Hibernate "
"reads data under Repeatable Read or Serializable isolation level. It can be "
"re-acquired by explicit user request."
msgstr ""
"<literal>LockMode.READ est obtenu automatiquement quand Hibernate "
"lit des données dans un contexte d'isolation <literal>Repeatable ReadSerializable. Peut être ré-obtenu "
"explicitement via une requête d'utilisateur. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>LockMode.NONE represents the absence of a lock. All "
"objects switch to this lock mode at the end of a <literal>Transactionupdate()"
"</literal> or saveOrUpdate() also start out in this lock "
"mode."
msgstr ""
"<literal>LockMode.NONE représente l'absence de verrouillage. Tous "
"les objets migrent vers ce mode à la fin d'une <literal>Transaction commencent également leur cycle de vie "
"dans ce mode verrouillé. "

#. Tag: para
#, no-c-format
msgid ""
"The \"explicit user request\" is expressed in one of the following ways:"
msgstr ""
"Les requêtes explicites d'utilisateur sont exprimées d'une des manières "
"suivantes :"

#. Tag: para
#, no-c-format
msgid ""
"A call to <literal>Session.load(), specifying a LockMode, en spécifiant un niveau "
"verrouillage <literal>LockMode ."

#. Tag: para
#, no-c-format
msgid "A call to <literal>Session.lock()."
msgstr "Un appel à <literal>Session.lock()."

#. Tag: para
#, no-c-format
msgid "A call to <literal>Query.setLockMode()."
msgstr "Une appel à <literal>Query.setLockMode()."

#. Tag: para
#, no-c-format
msgid ""
"If <literal>Session.load() is called with UPGRADEUPGRADE_NOWAIT, and the requested object was "
"not yet loaded by the session, the object is loaded using "
"<literal>SELECT ... FOR UPDATE. If load() is "
"called for an object that is already loaded with a less restrictive lock "
"than the one requested, Hibernate calls <literal>lock() for that "
"object."
msgstr ""
"Si <literal>Session.load() est appelé avec le paramètre de niveau "
"de verrouillage <literal>UPGRADE ou UPGRADE_NOWAITload() est appelée pour un objet "
"déjà en session avec un verrouillage moindre que celui demandé, Hibernate "
"appellera la méthode <literal>lock() pour cet objet."

#. Tag: para
#, no-c-format
msgid ""
"<literal>Session.lock() performs a version number check if the "
"specified lock mode is <literal>READ, UPGRADE "
"or <literal>UPGRADE_NOWAIT. In the case of UPGRADEUPGRADE_NOWAIT, SELECT ... FOR "
"UPDATE</literal> is used."
msgstr ""
"<literal>Session.lock() effectue une vérification de version si le "
"niveau de verrouillage est <literal>READ , UPGRADEUPGRADE_NOWAIT . Dans le cas des niveaux "
"<literal>UPGRADE ou UPGRADE_NOWAIT , une "
"requête <literal>SELECT ... FOR UPDATE sera utilisée."

#. Tag: para
#, no-c-format
msgid ""
"If the requested lock mode is not supported by the database, Hibernate uses "
"an appropriate alternate mode instead of throwing an exception. This ensures "
"that applications are portable."
msgstr ""
"Si une base de données ne supporte pas le niveau de verrouillage demandé, "
"Hibernate utilisera un niveau alternatif convenable au lieu de lancer une "
"exception. Ceci assurera la portabilité de vos applications."

#. Tag: title
#, no-c-format
msgid "Connection release modes"
msgstr "Modes de libération de connexion"

#. Tag: para
#, no-c-format
msgid ""
"One of the legacies of Hibernate 2.x JDBC connection management meant that a "
"<literal>Session would obtain a connection when it was first "
"required and then maintain that connection until the session was closed. "
"Hibernate 3.x introduced the notion of connection release modes that would "
"instruct a session how to handle its JDBC connections. The following "
"discussion is pertinent only to connections provided through a configured "
"<literal>ConnectionProvider. User-supplied connections are outside "
"the breadth of this discussion. The different release modes are identified "
"by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode obtenait une connexion dès "
"qu'elle en avait besoin et la libérait une fois la session fermée. Hibernate "
"3.x a introduit les modes de libération de connexion pour indiquer à la "
"session comment gérer les transactions JDBC. Notez que la discussion "
"suivante n'est pertinente que pour des connexions fournies par un "
"<literal>ConnectionProvider, celles gérées par l'utilisateur "
"dépassent l'objectif de cette discussion. Les différents modes de libération "
"sont identifiés par les valeurs énumérées de <literal>org.hibernate."
"ConnectionReleaseMode</literal> :"

#. Tag: para
#, no-c-format
msgid ""
"<literal>ON_CLOSE: is the legacy behavior described above. The "
"Hibernate session obtains a connection when it first needs to perform some "
"JDBC access and maintains that connection until the session is closed."
msgstr ""
"<literal>ON_CLOSE - est essentiellement le comportement passé "
"décrit ci-dessus. La session Hibernate obtient une connexion lorsqu'elle en "
"a besoin et la garde jusqu'à ce que la session se ferme. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>AFTER_TRANSACTION: releases connections after a "
"<literal>org.hibernate.Transaction has been completed."
msgstr ""
"<literal>AFTER_TRANSACTION - indique de relâcher la connexion "
"après qu'une <literal>org.hibernate.Transaction soit achevée. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>AFTER_STATEMENT (also referred to as aggressive release): "
"releases connections after every statement execution. This aggressive "
"releasing is skipped if that statement leaves open resources associated with "
"the given session. Currently the only situation where this occurs is through "
"the use of <literal>org.hibernate.ScrollableResults."
msgstr ""
"<literal>AFTER_STATEMENT (aussi appelé libération brutale) - "
"indique de relâcher les connexions après chaque exécution d'un statement. Ce "
"relâchement agressif est annulé si ce statement laisse des ressources "
"associées à une session donnée ouvertes, actuellement ceci n'arrive que lors "
"de l'utilisation de <literal>org.hibernate.ScrollableResults. "

#. Tag: para
#, no-c-format
msgid ""
"The configuration parameter <literal>hibernate.connection.release_mode (the default): this choice delegates to the release "
"mode returned by the <literal>org.hibernate.transaction.TransactionFactory."
"getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this "
"returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, "
"this returns ConnectionReleaseMode.AFTER_TRANSACTION. Do not change this "
"default behavior as failures due to the value of this setting tend to "
"indicate bugs and/or invalid assumptions in user code."
msgstr ""
"<literal>auto (valeur par défaut) - ce choix délègue le choix de "
"libération à la méthode <literal>org.hibernate.transaction."
"TransactionFactory.getDefaultReleaseMode()</literal> Pour la "
"JTATransactionFactory, elle retourne ConnectionReleaseMode.AFTER_STATEMENT; "
"pour JDBCTransactionFactory, elle retourne ConnectionReleaseMode."
"AFTER_TRANSACTION. C'est rarement une bonne idée de changer ce comportement "
"par défaut puisque les erreurs soulevées par ce paramétrage tend à indiquer "
"la présence de bogues et/ou d'erreurs dans le code de l'utilisateur. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>on_close: uses ConnectionReleaseMode.ON_CLOSE. This "
"setting is left for backwards compatibility, but its use is discouraged."
msgstr ""
"<literal>on_close - indique d'utiliser ConnectionReleaseMode."
"ON_CLOSE. Ce paramétrage existe pour garantir la compatibilité avec les "
"versions précédentes, mais ne devrait plus être utilisé. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>after_transaction: uses ConnectionReleaseMode."
"AFTER_TRANSACTION. This setting should not be used in JTA environments. Also "
"note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is "
"considered to be in auto-commit mode, connections will be released as if the "
"release mode were AFTER_STATEMENT."
msgstr ""
"<literal>after_transaction - indique d'utiliser "
"ConnectionReleaseMode.AFTER_TRANSACTION. Ne devrait pas être utilisé dans "
"les environnements JTA. Notez aussi qu'avec ConnectionReleaseMode."
"AFTER_TRANSACTION, si une session est considérée comme étant en mode auto-"
"commit les connexions seront relâchées comme si le mode était "
"AFTER_STATEMENT. "

#. Tag: para
#, no-c-format
msgid ""
"<literal>after_statement: uses ConnectionReleaseMode."
"AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider). If not, the release mode "
"is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only "
"safe in environments where we can either re-acquire the same underlying JDBC "
"connection each time you make a call into <literal>ConnectionProvider."
"getConnection()</literal> or in auto-commit environments where it does not "
"matter if we re-establish the same connection."
msgstr ""
"<literal>after_statement - indique d'utiliser "
"ConnectionReleaseMode.AFTER_STATEMENT. De plus, le "
"<literal>ConnectionProvider utilisé est consulté pour savoir s'il "
"supporte ce paramétrage (<literal>supportsAggressiveRelease()). Si "
"ce n'est pas le cas, le mode de libération est ré-initialisé à "
"ConnectionReleaseMode.AFTER_TRANSACTION. Ce paramétrage n'est sûr que dans "
"les environnements où il est possible d'obtenir à nouveau la même connexion "
"JDBC à chaque fois que l'on fait un appel de <literal>ConnectionProvider."
"getConnection()</literal> ou dans les environnements auto-commit où il n'est "
"pas important d'obtenir plusieurs fois la même connexion. "