[jboss-cvs] JBossAS SVN: r89158 - projects/docs/enterprise/4.3.3/Hibernate/Annotations_Reference_Guide/fr-FR.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Wed May 20 02:21:26 EDT 2009
Author: croe at redhat.com
Date: 2009-05-20 02:21:26 -0400 (Wed, 20 May 2009)
New Revision: 89158
Modified:
projects/docs/enterprise/4.3.3/Hibernate/Annotations_Reference_Guide/fr-FR/Entity.po
Log:
translation in progress
Modified: projects/docs/enterprise/4.3.3/Hibernate/Annotations_Reference_Guide/fr-FR/Entity.po
===================================================================
--- projects/docs/enterprise/4.3.3/Hibernate/Annotations_Reference_Guide/fr-FR/Entity.po 2009-05-20 05:01:17 UTC (rev 89157)
+++ projects/docs/enterprise/4.3.3/Hibernate/Annotations_Reference_Guide/fr-FR/Entity.po 2009-05-20 06:21:26 UTC (rev 89158)
@@ -9,7 +9,7 @@
"Project-Id-Version: Entity\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-05-12 01:33+0000\n"
-"PO-Revision-Date: 2009-05-19 16:17+1000\n"
+"PO-Revision-Date: 2009-05-20 16:20+1000\n"
"Last-Translator: Corina Roe <croe at redhat.com>\n"
"Language-Team: French <i18 at redhat.com>\n"
"MIME-Version: 1.0\n"
@@ -4499,7 +4499,7 @@
#: Entity.xml:991
#, no-c-format
msgid "a property"
-msgstr ""
+msgstr "une propriété"
#. Tag: para
#: Entity.xml:996
@@ -4509,7 +4509,7 @@
"class, all the properties of the given class inherit the access type. For "
"root entities, the access type is considered to be the default one for the "
"whole hierarchy (overridable at class or property level)."
-msgstr ""
+msgstr "Le type d'accès est surchargé par l'élément annoté. S'il est surchargé sur une classe, toutes les propriétés de la classe donnée héritent le type d'accès. Pour les entités root, le type d'accès est considéré être la valeur par défaut de toute la hiérarchie (surchargeable au niveau de la classe ou de la propriété)."
#. Tag: para
#: Entity.xml:999
@@ -4519,7 +4519,7 @@
"annotations, if the access type is marked as \"field\", the fields are "
"scanned for annotations. Otherwise the elements marked with @Id or "
"@embeddedId are scanned."
-msgstr ""
+msgstr "Si le type d'accès est marqué \"property\", les getters seront balayés pour trouver des annotations. Si le type d'accès est marqué \"field\", les champs seront balayés pour trouver des annotations. Sinon, les éléments qui comprennent @ld ou @embeddedld seront également balayés."
#. Tag: para
#: Entity.xml:1002
@@ -4531,6 +4531,8 @@
"(\"property\")</literal>, the access type will then be property for this "
"attribute, the the annotations still have to be carried on the field."
msgstr ""
+"Vous pouvez surcharger un type d'accès pour une propriété, mais l'élément à annoter ne sera pas influencé :par exemple une entité ayant pour type d'accès <literal>field</literal>, peut annoter un champ avec <literal>@AccessType"
+"(\"property\")</literal>, le type d'accès sera alors une propriété pour cet attribut, et les annotations devront toujours être mises sur le champ."
#. Tag: para
#: Entity.xml:1005
@@ -4540,7 +4542,7 @@
"access type is used (even if an access type has been define on an "
"intermediate superclass or embeddable object). The russian doll principle "
"does not apply."
-msgstr ""
+msgstr "Si une superclasse ou un objet imbriccable n'est pas annoté, le type d'accès de l'entité root sera utilisé (même si le type d'accès a été défini sur une superclasse intermédiaire ou sur un objet imbriquable). Le principe de la poupée russe ne s'applique pas."
#. Tag: programlisting
#: Entity.xml:1008
@@ -4585,12 +4587,50 @@
" }\n"
"}"
msgstr ""
+"@Entity\n"
+"public class Person implements Serializable {\n"
+" @Id @GeneratedValue //access type field\n"
+" Integer id;\n"
+"\n"
+" @Embedded\n"
+" @AttributeOverrides({\n"
+" @AttributeOverride(name = \"iso2\", column = @Column(name = \"bornIso2"
+"\")),\n"
+" @AttributeOverride(name = \"name\", column = @Column(name = "
+"\"bornCountryName\"))\n"
+" })\n"
+" Country bornIn;\n"
+"}\n"
+"\n"
+"@Embeddable<emphasis role=\"bold\">@AccessType(\"property\")</emphasis> //"
+"override access type for all properties in Country\n"
+"public class Country implements Serializable {\n"
+" private String iso2;\n"
+" private String name;\n"
+"\n"
+" public String getIso2() {\n"
+" return iso2;\n"
+" }\n"
+"\n"
+" public void setIso2(String iso2) {\n"
+" this.iso2 = iso2;\n"
+" }\n"
+"\n"
+" @Column(name = \"countryName\")\n"
+" public String getName() {\n"
+" return name;\n"
+" }\n"
+"\n"
+" public void setName(String name) {\n"
+" this.name = name;\n"
+" }\n"
+"}"
#. Tag: title
#: Entity.xml:1009
#, no-c-format
msgid "Formula"
-msgstr ""
+msgstr "Formule"
#. Tag: para
#: Entity.xml:1010
@@ -4601,7 +4641,7 @@
"SQL fragment (aka formula) instead of mapping a property into a column. This "
"kind of property is read only (its value is calculated by your formula "
"fragment)."
-msgstr ""
+msgstr "Parfois, vous souhaiteriez que la base de données puisse effectuer quelques opérations pour vous à la place de JVM. Vous souhaiteriez également créer certaines colonnes virtuelles. Vous pouvez utiliser un fragment SQL (alias formule) au lieu de mapper une propriété dans une colonne. Ce genre de propriété est en lecture-seule (sa valeur est calculée par votre fragment de formule)."
#. Tag: programlisting
#: Entity.xml:1013
@@ -4610,18 +4650,20 @@
"@Formula(\"obj_length * obj_height * obj_width\")\n"
"public long getObjectVolume()"
msgstr ""
+"@Formula(\"obj_length * obj_height * obj_width\")\n"
+"public long getObjectVolume()"
#. Tag: para
#: Entity.xml:1014
#, no-c-format
msgid "The SQL fragment can be as complex as you want avec even include subselects."
-msgstr ""
+msgstr "Le fragment SQL peut être aussi complexe que vous le souhaitez, voir même inclure des sous-sélections."
#. Tag: title
#: Entity.xml:1017
#, no-c-format
msgid "Type"
-msgstr ""
+msgstr "Type"
#. Tag: para
#: Entity.xml:1018
@@ -4631,7 +4673,7 @@
"hibernate type used: this is generally not necessary since the type is "
"correctly inferred by Hibernate. Please refer to the Hibernate reference "
"guide for more informations on the Hibernate types."
-msgstr ""
+msgstr "<literal>@org.hibernate.annotations.Type</literal> surcharge le type hibernate utilisé par défaut : cela n'est normalement pas nécessaire puisque le type est correctement inférré par Hibernate. Veuillez vous reporter au guide de référence Hibernate pour davantage d'informations sur les types d'Hibernate."
#. Tag: para
#: Entity.xml:1021
@@ -4643,6 +4685,8 @@
"Note that these definitions will be global for the session factory (even at "
"the class level) and that type definition has to be defined before any usage."
msgstr ""
+"<literal>@org.hibernate.annotations.TypeDef</literal> and <literal>@org."
+"hibernate.annotations.TypeDefs</literal> vous permet de déclarer des définitions de type. Ces annotations sont situées au niveau du package ou de la classe. Notez que ces définitions seront globales pour l'usine de sessions (même au niveau de la classe) et que la défnition du type devra être défini avant tout usage."
#. Tag: programlisting
#: Entity.xml:1024
@@ -4668,6 +4712,25 @@
" ...\n"
"}"
msgstr ""
+"@TypeDefs(\n"
+" {\n"
+" @TypeDef(\n"
+" name=\"caster\",\n"
+" typeClass = CasterStringType.class,\n"
+" parameters = {\n"
+" @Parameter(name=\"cast\", value=\"lower\")\n"
+" }\n"
+" )\n"
+" }\n"
+")\n"
+"package org.hibernate.test.annotations.entity;\n"
+"\n"
+"...\n"
+"public class Forest {\n"
+" @Type(type=\"caster\")\n"
+" public String getSmallText() {\n"
+" ...\n"
+"}"
#. Tag: para
#: Entity.xml:1025
@@ -4675,7 +4738,7 @@
msgid ""
"When using composite user type, you will have to express column definitions. "
"The <literal>@Columns</literal> has been introduced for that purpose."
-msgstr ""
+msgstr "Quand on utilise un type d'utilisation composite, vous devrez exprimer les définitions de colonnes. <literal>@Columns</literal> a été introduit dans ce but."
#. Tag: programlisting
#: Entity.xml:1028
@@ -4698,12 +4761,28 @@
" ...\n"
"}"
msgstr ""
+"@Type(type=\"org.hibernate.test.annotations.entity.MonetaryAmountUserType"
+"\")\n"
+"@Columns(columns = {\n"
+" @Column(name=\"r_amount\"),\n"
+" @Column(name=\"r_currency\")\n"
+"})\n"
+"public MonetaryAmount getAmount() {\n"
+" return amount;\n"
+"}\n"
+"\n"
+"\n"
+"public class MonetaryAmount implements Serializable {\n"
+" private BigDecimal amount;\n"
+" private Currency currency;\n"
+" ...\n"
+"}"
#. Tag: title
#: Entity.xml:1029
#, no-c-format
msgid "Index"
-msgstr ""
+msgstr "Index"
#. Tag: para
#: Entity.xml:1030
@@ -4712,7 +4791,7 @@
"You can define an index on a particular column using the <literal>@Index</"
"literal> annotation on a one column property, the columnNames attribute will "
"then be ignored"
-msgstr ""
+msgstr "Vous pouvez définir un index d'une colonne particulière en utilisant l'annotation <literal>@Index</literal> sur une propriété de colonne, l'attribut columnNames sera alors ignoré."
#. Tag: programlisting
#: Entity.xml:1033
@@ -4724,12 +4803,17 @@
" return storyPart1;\n"
"}"
msgstr ""
+"@Column(secondaryTable=\"Cat1\")\n"
+"@Index(name=\"story1index\")\n"
+"public String getStoryPart1() {\n"
+" return storyPart1;\n"
+"}"
#. Tag: title
#: Entity.xml:1034
#, no-c-format
msgid "@Parent"
-msgstr ""
+msgstr "@Parent"
#. Tag: para
#: Entity.xml:1035
@@ -4737,7 +4821,7 @@
msgid ""
"When inside an embeddable object, you can define one of the properties as a "
"pointer back to the owner element."
-msgstr ""
+msgstr "Quand vous vous trouvez à l'intérieur d'un objet imbriquable, vous pouvez définir une des propriétés en tant que pointeur vers l'élément du propriétaire."
#. Tag: programlisting
#: Entity.xml:1038
@@ -4758,12 +4842,26 @@
"\n"
"person == person.address.owner"
msgstr ""
+"@Entity\n"
+"public class Person {\n"
+" @Embeddable public Address address;\n"
+" ...\n"
+"}\n"
+"\n"
+"@Embeddable\n"
+"public class Address {\n"
+" @Parent public Person owner;\n"
+" ...\n"
+"}\n"
+"\n"
+"\n"
+"person == person.address.owner"
#. Tag: title
#: Entity.xml:1039
#, no-c-format
msgid "Generated properties"
-msgstr ""
+msgstr "Propriétés générées"
#. Tag: para
#: Entity.xml:1040
@@ -4772,7 +4870,7 @@
"Some properties are generated at insert or update time by your database. "
"Hibernate can deal with such properties and triggers a subsequent select to "
"read these properties."
-msgstr ""
+msgstr "Certaines propriétés sont générées en cours d'insersion ou de mise à jour par votre base de données. Hibernate peut gérer de telles propriétés et déclencher une sélection en conséquence pour sélectionner ces propriétés."
#. Tag: programlisting
#: Entity.xml:1043
@@ -4789,6 +4887,16 @@
" public String latitude;\n"
"}"
msgstr ""
+"@Entity\n"
+"public class Antenna {\n"
+" @Id public Integer id;\n"
+" @Generated(GenerationTime.ALWAYS) @Column(insertable = false, updatable "
+"= false)\n"
+" public String longitude;\n"
+"\n"
+" @Generated(GenerationTime.INSERT) @Column(insertable = false)\n"
+" public String latitude;\n"
+"}"
#. Tag: para
#: Entity.xml:1044
@@ -4800,7 +4908,7 @@
"the property must not contains insertable columns, when GenerationTime."
"ALWAYS is chosen, the property must not contains insertable nor updatable "
"columns."
-msgstr ""
+msgstr "Annotez votre propriété en tant que <literal>@Generated</literal>. Vous devez vous assurer que votre capacité d'insersion et de mise à jour ne rentrent pas en conflit avec la stratégie de génération que vous avez choisie. Quand GenerationTime.INSERT est sélectionné, la propriété ne doit pas comprendre de colonnes inserrables; quand GenerationTime.ALWAYS est choisi, la propriété ne doit pas contenir de colonnes insérables ou pouvant être mises à jour."
#. Tag: para
#: Entity.xml:1047
@@ -4810,12 +4918,15 @@
"</literal> by design, it has to be either <literal>NEVER</literal> or "
"<literal>ALWAYS</literal>."
msgstr ""
+"Les propriétés de <literal>@Version</literal> ne peuvent pas être <literal>@Generated(INSERT)"
+"</literal> par design. On doit avoir <literal>NEVER</literal> ou "
+"<literal>ALWAYS</literal>."
#. Tag: title
#: Entity.xml:1050
#, no-c-format
msgid "@Target"
-msgstr ""
+msgstr "@Target"
#. Tag: para
#: Entity.xml:1051
@@ -4826,7 +4937,7 @@
"can use <literal>@Target</literal> to by pass the reflection guessing "
"mechanism (very much like the <literal>targetEntity</literal> attribute "
"available on associations."
-msgstr ""
+msgstr "Parfois, le type qui est deviné par réflection n'est pas celui que vous souhaitez qu'Hibernate utilise. C'est surtout vrai pour des composants quand on utilise une interface. Vous pouvez utiliser <literal>@Target</literal> pour éviter le mécanisme de réflection (similaire à l'attribut <literal>targetEntity</literal> disponible pour les associations)."
#. Tag: programlisting
#: Entity.xml:1054
@@ -4838,12 +4949,17 @@
" return owner;\n"
" }"
msgstr ""
+"@Embedded\n"
+" <emphasis role=\"bold\">@Target(OwnerImpl.class)</emphasis>\n"
+" public Owner getOwner() {\n"
+" return owner;\n"
+" }"
#. Tag: title
#: Entity.xml:1055
#, no-c-format
msgid "Inheritance"
-msgstr ""
+msgstr "Héritage"
#. Tag: para
#: Entity.xml:1056
@@ -4855,7 +4971,7 @@
"<literal>@DiscriminatorFormula</literal> is a replacement of "
"<literal>@DiscriminatorColumn</literal> and use a SQL fragment as a formula "
"for discriminator resolution (no need to have a dedicated column)."
-msgstr ""
+msgstr "SINGLE_TABLE est une stratégie très puissante mais parfois, et surtout pour les ystèmes pré-existants, vous ne pouvez pas ajouter de colonne de discriminateur supplémentaire. Dans ce but, Hibernate a introduit la notion de formule de discriminator : <literal>@DiscriminatorFormula</literal> est un remplacement de <literal>@DiscriminatorColumn</literal> et utilise un fragment SQL comme formule pour la résolution de discriminator (nul besoin de colonne dédiée à ce but)."
#. Tag: programlisting
#: Entity.xml:1059
@@ -4866,6 +4982,10 @@
"forest_type end\")\n"
"public class Forest { ... }"
msgstr ""
+"@Entity\n"
+"@DiscriminatorForumla(\"case when forest_type is null then 0 else "
+"forest_type end\")\n"
+"public class Forest { ... }"
#. Tag: para
#: Entity.xml:1060
@@ -4879,12 +4999,15 @@
"<literal>@DiscriminatorColumn</literal>). Hibernate will then list the "
"available values when loading the entities."
msgstr ""
+"Par défaut, quand vous cherchez les entités supérieures, Hibernate de place pas de clause de restriction sur la colonne du discriminateur. Cela peut poser un problème si cette colonne contient des valeurs qui ne sont pas mappées dans votre hiérarchie (par <literal>@DiscriminatorValue</literal>). Pour régler ce problème, vous pouvez utiliser "
+"<literal>@ForceDiscriminator</literal> (au niveau de la classe, à côté de "
+"<literal>@DiscriminatorColumn</literal>). Hibernate va alors lister les valeurs disponibles au moment du téléchargement des entités."
#. Tag: title
#: Entity.xml:1063
#, no-c-format
msgid "Single Association related annotations"
-msgstr ""
+msgstr "Annotations liées à des associations simples"
#. Tag: para
#: Entity.xml:1064
@@ -4899,6 +5022,9 @@
"literal> (with FK), <literal>@ManyToOne</literal>, <literal>@OneToMany</"
"literal> or <literal>@ManyToMany</literal> association."
msgstr ""
+"Par défaut, quand Hibernate ne peut pas résoudre l'association parce que l'élément associé qu'on espère n'est pas dans la base de données (id erronée dans la colonne d'association), Hibernate crée une exception. Cela peut popser un problème pour les anciens schémas et pour les schémas qui ne sont pas entretenus convenablement. Vous pouvez demander à Hibernate d'ignorer ces éléments au lieu de créer une exception en utilisant une association <literal>@OneToOne</"
+"literal> (avec FK), <literal>@ManyToOne</literal>, <literal>@OneToMany</"
+"literal> ou <literal>@ManyToMany</literal>."
#. Tag: programlisting
#: Entity.xml:1067
@@ -4913,6 +5039,14 @@
" ...\n"
"}"
msgstr ""
+"@Entity\n"
+"public class Child {\n"
+" ...\n"
+" @ManyToOne\n"
+" @NotFound(action=NotFoundAction.IGNORE)\n"
+" public Parent getParent() { ... }\n"
+" ...\n"
+"}"
#. Tag: para
#: Entity.xml:1068
@@ -4920,7 +5054,7 @@
msgid ""
"Sometimes you want to delegate to your database the deletion of cascade when "
"a given entity is deleted."
-msgstr ""
+msgstr "Parfois, vous souhaitez peut-être déléguer la suppression de cascade à votre base de données quand une entité donnée est supprimée."
#. Tag: programlisting
#: Entity.xml:1071
@@ -4935,6 +5069,14 @@
" ...\n"
"}"
msgstr ""
+"@Entity\n"
+"public class Child {\n"
+" ...\n"
+" @ManyToOne\n"
+" @OnDelete(action=OnDeleteAction.CASCADE)\n"
+" public Parent getParent() { ... }\n"
+" ...\n"
+"}"
#. Tag: para
#: Entity.xml:1072
@@ -4942,7 +5084,7 @@
msgid ""
"In this case Hibernate generates a cascade delete constraint at the database "
"level."
-msgstr ""
+msgstr "Dans un tel cas, Hibernate génère une contrainte de suppression de cascade au niveau de la base de données."
#. Tag: para
#: Entity.xml:1075
@@ -4951,7 +5093,7 @@
"Foreign key constraints, while generated by Hibernate, have a fairly "
"unreadable name. You can override the constraint name by use "
"<literal>@ForeignKey</literal>."
-msgstr ""
+msgstr "Les contraines de clés étrangères, quand elles sont générées par Hibernate, ont un nom assez illisible. Vous pouvez surcharger le nom de la contrainte en utilisant <literal>@ForeignKey</literal>."
#. Tag: programlisting
#: Entity.xml:1078
@@ -4969,12 +5111,23 @@
"alter table Child add constraint FK_PARENT foreign key (parent_id) "
"references Parent"
msgstr ""
+"@Entity\n"
+"public class Child {\n"
+" ...\n"
+" @ManyToOne\n"
+" <emphasis role=\"bold\">@ForeignKey(name=\"FK_PARENT\")</emphasis>\n"
+" public Parent getParent() { ... }\n"
+" ...\n"
+"}\n"
+"\n"
+"alter table Child add constraint FK_PARENT foreign key (parent_id) "
+"references Parent"
#. Tag: title
#: Entity.xml:1079
#, no-c-format
msgid "Lazy options and fetching modes"
-msgstr ""
+msgstr "Options lazy et modes de récupéraiton"
#. Tag: para
#: Entity.xml:1080
@@ -4984,7 +5137,7 @@
"and fetching modes, however Hibernate has a much more option set in this "
"area. To fine tune the lazy loading and fetching strategies, some additional "
"annotations have been introduced:"
-msgstr ""
+msgstr "EJB3 est fourni avec l'option <literal>fetch</literal> pour déterminer le chargement à la demande et les modes de récupération. Mais Hibernate a plus d'une option à ce sujet. Pour définir plus précisément les stratégies de récupération et de chargement à la demande, on a jouté quelques annotations supplémentaires :"
#. Tag: para
#: Entity.xml:1085
@@ -4997,6 +5150,9 @@
"enhancement based lazy loading - note that build time bytecode processing is "
"necessary) and <literal>FALSE</literal> (association not lazy)"
msgstr ""
+"<literal>@LazyToOne</literal>: définit l'option de lazyness sur les associations "
+"<literal>@ManyToOne</literal> et <literal>@OneToOne</literal>. "
+"<literal>LazyToOneOption</literal> pet être <literal>PROXY</literal> (c'est à dire en utilisant une chargement à la demande basé proxy), <literal>NO_PROXY</literal> (en utilisant un chargement à la demande basé bytecode - notez que le traitement de build time bytecode est nécessaire) et <literal>FALSE</literal> (association non lazy)"
#. Tag: para
#: Entity.xml:1092
@@ -5011,6 +5167,10 @@
"collections when loading all the elements is not necessary) and FALSE "
"(association not lazy)"
msgstr ""
+"<literal>@LazyCollection</literal>: définit l'option lazyness des associations "
+"<literal>@ManyToMany</literal>et de <literal>@OneToMany</literal> "
+"associations. LazyCollectionOption peut être <literal>TRUE</literal> (la collection est lazy et sera chargée quand on accède à son état), "
+"<literal>EXTRA</literal> (la collection est lazy et toutes les opérations vont essayer d'éviter le chargement de collection, cela est particulièement utile pour les énormes collections quand il n'est pas utile de télécharger tous les éléments) et FALSE (associaitons non lazy)"
#. Tag: para
#: Entity.xml:1099
@@ -5026,120 +5186,125 @@
"overrides any lazy attribute (an association loaded through a <literal>JOIN</"
"literal> strategy cannot be lazy)."
msgstr ""
+"<literal>@Fetch</literal>: définit la stratégie utilisée pour télécharger l'association. <literal>FetchMode</literal> peut être <literal>SELECT</literal> "
+"(une sélection est déclenchée quand une association a besoin d'être téléchargée), "
+"<literal>SUBSELECT</literal> (uniquement disponible pour collections, utiliser une stratégie de sous-sélection - veuillez, pour cela, vous reporter à la Documentation de référence Hibernate pour ddavantage d'informations) ou <literal>JOIN</literal> (utiliser un SQL JOIN pour télécharger l'association quand vous téléchargez l'entité du propriétaire). <literal>JOIN</literal> surcharge tout attribut lazy (une association téléchargée par une stratégie"
+" <literal>JOIN</"
+"literal> ne peut pas être lazy)."
#. Tag: para
#: Entity.xml:1106
#, no-c-format
msgid "The Hibernate annotations overrides the EJB3 fetching options."
-msgstr ""
+msgstr "Les annotations Hibernate surchargent les options de récupération EJB3."
#. Tag: title
#: Entity.xml:1110
#, no-c-format
msgid "Lazy and fetch options equivalent"
-msgstr ""
+msgstr "Les équivalents aux options laszy et fetch"
#. Tag: entry
#: Entity.xml:1114
#, no-c-format
msgid "Annotations"
-msgstr ""
+msgstr "Annotations"
#. Tag: entry
#: Entity.xml:1117
#, no-c-format
msgid "Lazy"
-msgstr ""
+msgstr "Lazy"
#. Tag: entry
#: Entity.xml:1120
#, no-c-format
msgid "Fetch"
-msgstr ""
+msgstr "Fetch"
#. Tag: entry
#: Entity.xml:1127
#, no-c-format
msgid "@[One|Many]ToOne](fetch=FetchType.LAZY)"
-msgstr ""
+msgstr "@[One|Many]ToOne](fetch=FetchType.LAZY)"
#. Tag: entry
#: Entity.xml:1130
#, no-c-format
msgid "@LazyToOne(PROXY)"
-msgstr ""
+msgstr "@LazyToOne(PROXY)"
#. Tag: entry
#: Entity.xml:1133 Entity.xml:1155
#, no-c-format
msgid "@Fetch(SELECT)"
-msgstr ""
+msgstr "@Fetch(SELECT)"
#. Tag: entry
#: Entity.xml:1138
#, no-c-format
msgid "@[One|Many]ToOne](fetch=FetchType.EAGER)"
-msgstr ""
+msgstr "@[One|Many]ToOne](fetch=FetchType.EAGER)"
#. Tag: entry
#: Entity.xml:1141
#, no-c-format
msgid "@LazyToOne(FALSE)"
-msgstr ""
+msgstr "@LazyToOne(FALSE)"
#. Tag: entry
#: Entity.xml:1144 Entity.xml:1166
#, no-c-format
msgid "@Fetch(JOIN)"
-msgstr ""
+msgstr "@Fetch(JOIN)"
#. Tag: entry
#: Entity.xml:1149
#, no-c-format
msgid "@ManyTo[One|Many](fetch=FetchType.LAZY)"
-msgstr ""
+msgstr "@ManyTo[One|Many](fetch=FetchType.LAZY)"
#. Tag: entry
#: Entity.xml:1152
#, no-c-format
msgid "@LazyCollection(TRUE)"
-msgstr ""
+msgstr "@LazyCollection(TRUE)"
#. Tag: entry
#: Entity.xml:1160
#, no-c-format
msgid "@ManyTo[One|Many](fetch=FetchType.EAGER)"
-msgstr ""
+msgstr "@ManyTo[One|Many](fetch=FetchType.EAGER)"
#. Tag: entry
#: Entity.xml:1163
#, no-c-format
msgid "@LazyCollection(FALSE)"
-msgstr ""
+msgstr "@LazyCollection(FALSE)"
#. Tag: title
#: Entity.xml:1173
#, no-c-format
msgid "Collection related annotations"
-msgstr ""
+msgstr "Annotatopms liées à collection"
#. Tag: title
#: Entity.xml:1174
#, no-c-format
msgid "Enhance collection settings"
-msgstr ""
+msgstr "Améliore le paramétrage de collection"
#. Tag: para
#: Entity.xml:1175
#, no-c-format
msgid "It is possible to set"
-msgstr ""
+msgstr "Il est possible de paramétrer"
#. Tag: para
#: Entity.xml:1178
#, no-c-format
msgid "the batch size for collections using @BatchSize"
-msgstr ""
+msgstr "la taille du batch pour les collections en utilisant @BatchSize"
#. Tag: para
#: Entity.xml:1183
@@ -5147,25 +5312,25 @@
msgid ""
"the where clause, using @Where (applied on the target entity) or "
"@WhereJoinTable (applied on the association table)"
-msgstr ""
+msgstr "la clause where, qui utilise @Where (appliqué à l'entité cible) ou @WhereJoinTable (appliqué à la table d'association)"
#. Tag: para
#: Entity.xml:1188
#, no-c-format
msgid "the check clause, using @Check"
-msgstr ""
+msgstr "la clause de vérification, utilisant @Check"
#. Tag: para
#: Entity.xml:1193
#, no-c-format
msgid "the SQL order by clause, using @OrderBy"
-msgstr ""
+msgstr "l'ordre SQL par clause, utilisant @OrderBy"
#. Tag: para
#: Entity.xml:1198
#, no-c-format
msgid "the delete cascade strategy through @OnDelete(action=OnDeleteAction.CASCADE)"
-msgstr ""
+msgstr "la stratégie delete cascade par @OnDelete(action=OnDeleteAction.CASCADE"
#. Tag: para
#: Entity.xml:1204
@@ -5179,6 +5344,8 @@
"either a <classname>SortedSet</classname> or a <classname>SortedMap</"
"classname> interface."
msgstr ""
+"Vous pouvez également déclarer un comparateur de triage (sort comparator). Utiliser pour cela l'annotation <literal>@Sort</literal>. Exprimer le type de comparateur que vous voulez: non trié (unsorted), naturel (natural) ou personnalisé (custom). SI vous souhaitez utiliser votre propre implémentation de comparateur, vous devrez également exprimer votre classe d'implémentation en utilisant l'attribut <literal>comparator</literal>. Notez bien que vous aurez besoin d'utiliser soit <classname>SortedSet</classname>, soit <classname>SortedMap</"
+"classname>."
#. Tag: programlisting
#: Entity.xml:1207
@@ -5193,6 +5360,14 @@
" return tickets;\n"
" }"
msgstr ""
+"@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)\n"
+" @JoinColumn(name=\"CUST_ID\")\n"
+" @Sort(type = SortType.COMPARATOR, comparator = TicketComparator.class)\n"
+" @Where(clause=\"1=1\")\n"
+" @OnDelete(action=OnDeleteAction.CASCADE)\n"
+" public SortedSet<Ticket> getTickets() {\n"
+" return tickets;\n"
+" }"
#. Tag: para
#: Entity.xml:1208
@@ -5200,7 +5375,7 @@
msgid ""
"Please refer to the previous descriptions of these annotations for more "
"informations."
-msgstr ""
+msgstr "Veuillez vous reporter aux descriptions précédentes de ces annotations pour davantage d'informations."
#. Tag: para
#: Entity.xml:1211
@@ -5211,7 +5386,7 @@
"<literal>@ForeignKey</literal>. Note that this annotation has to be placed "
"on the owning side of the relationship, <literal>inverseName</literal> "
"referencing to the other side constraint."
-msgstr ""
+msgstr "Les contraintes de clés étrangères, malgré qu'elles soient générées par Hibernate, comportent un nom assez illisible. Vous pouvez surcharger le nom contraint en utilisant <literal>@ForeignKey</literal>. Nptez que cette annotation doit être placée sur la partie propriétaire de la relation, <literal>inverseName</literal> faisant référence à la contrainte de l'autre côté."
#. Tag: programlisting
#: Entity.xml:1214
@@ -5233,18 +5408,33 @@
"alter table Man_Woman add constraint TO_MAN_FK foreign key (man_id) "
"references Man"
msgstr ""
+"@Entity\n"
+"public class Woman {\n"
+" ...\n"
+" @ManyToMany(cascade = {CascadeType.ALL})\n"
+" <emphasis role=\"bold\">@ForeignKey(name = \"TO_WOMAN_FK\", inverseName "
+"= \"TO_MAN_FK\")</emphasis>\n"
+" public Set<Man> getMens() {\n"
+" return mens;\n"
+" }\n"
+"}\n"
+"\n"
+"alter table Man_Woman add constraint TO_WOMAN_FK foreign key (woman_id) "
+"references Woman\n"
+"alter table Man_Woman add constraint TO_MAN_FK foreign key (man_id) "
+"references Man"
#. Tag: title
#: Entity.xml:1215
#, no-c-format
msgid "Extra collection types"
-msgstr ""
+msgstr "Types de collection supplémentaires"
#. Tag: title
#: Entity.xml:1216
#, no-c-format
msgid "List"
-msgstr ""
+msgstr "List"
#. Tag: para
#: Entity.xml:1217
@@ -5257,6 +5447,8 @@
"value in DB that represent the first element (aka as base index). The usual "
"value is <literal>0</literal> or <literal>1</literal>."
msgstr ""
+"Au delà d'EJB3, Hibernate Annotations supporte <classname>List</classname> "
+"et <classname>Array</classname>. Mappez votre collection comme d'habitude, et ajoutez @<literal>IndexColumn</literal>. Cette annotation vous permettra de décrire une colonne qui contiendra l'index. Vous pouvez aussi déclarer la valeur de l'index en DB, qui représente le premier élément (alias index de base). La valeur habituelle est <literal>0</literal> ou bien <literal>1</literal>."
#. Tag: programlisting
#: Entity.xml:1220
@@ -5268,6 +5460,11 @@
" return drawers;\n"
"}"
msgstr ""
+"@OneToMany(cascade = CascadeType.ALL)\n"
+"@IndexColumn(name = \"drawer_position\", base=1)\n"
+"public List<Drawer> getDrawers() {\n"
+" return drawers;\n"
+"}"
#. Tag: para
#: Entity.xml:1222
@@ -5276,13 +5473,13 @@
"If you forgot to set <literal>@IndexColumn</literal>, the bag semantic is "
"applied. If you want the bag semantic without the limitations of it, "
"consider using <literal>@CollectionId</literal>."
-msgstr ""
+msgstr "SI vous oubliez de fixer <literal>@IndexColumn</literal>, la sémantique de bag s'applique. Si vous souhaitez avoir la sémantique de bag sans en subir ses limitations, considérez l'utilisation de <literal>@CollectionId</literal>."
#. Tag: title
#: Entity.xml:1226
#, no-c-format
msgid "<title>Map</title>"
-msgstr ""
+msgstr "<title>Map</title>"
#. Tag: para
#: Entity.xml:1227
@@ -5296,6 +5493,9 @@
"embeddable object, or you can use <literal>@org.hibernate.annotations."
"MapKeyManyToMany</literal> if your key is an entity."
msgstr ""
+"Les Annotations Hibernate supportent également les mappages de true Map, si <literal>@javax."
+"persistence.MapKey</literal> n'est pas déterminé, Hibernate mappera les éléments clé ou objets imbriqués dans leur(s) propres colonnes. Pour surcharger les colonnes par défaut, vous pourrez utiliser <literal>@org.hibernate.annotations.MapKey</literal>si votre clé est d'un type de base (<literal>mapkey</literal> par défaut) ou bien un objet imbriquable, ou encore, vous pourrez utiliser <literal>@org.hibernate.annotations."
+"MapKeyManyToMany</literal> si votre clé est une entité."
#. Tag: para
#: Entity.xml:1230
@@ -5306,6 +5506,8 @@
"target element to be used. This is especially useful if your collection does "
"not use generics (or if you use interfaces)."
msgstr ""
+"<literal>@org.hibernate.annotations.MapKey</literal> et <literal>@org."
+"hibernate.annotations.MapKeyManyToMany</literal> vous permettent de surcharger l'élément cible à utiliser. Cela est particulièrement utile si votre collection n'utilise pas de génériques (ou si vous utilisez des interfaces)."
#. Tag: programlisting
#: Entity.xml:1233
@@ -5317,12 +5519,17 @@
" private Map<Luggage, Size> sizePerLuggage = new HashMap<"
"Luggage, Size>();"
msgstr ""
+"@CollectionOfElements(targetElement = SizeImpl.class)\n"
+" @MapKeyManyToMany(<emphasis role=\"bold\">targetEntity = LuggageImpl."
+"class</emphasis>)\n"
+" private Map<Luggage, Size> sizePerLuggage = new HashMap<"
+"Luggage, Size>();"
#. Tag: title
#: Entity.xml:1234
#, no-c-format
msgid "Bidirectional association with indexed collections"
-msgstr ""
+msgstr "Association bidirectionnelle avec des collections indexées"
#. Tag: para
#: Entity.xml:1235
@@ -5334,6 +5541,8 @@
"property of the child class which maps to the index column, no problem, we "
"can continue using <literal>mappedBy</literal> on the collection mapping:"
msgstr ""
+"Une association bidirectionnelle pour laquelle une extrémité est représentée par <literal>@IndexColumn</literal> ou <literal>@org.hibernate.annotations.MapKey"
+"[ManyToMany]</literal> attire une certaine considération. S'il y a une propriété de la classe du dépendant qui mappe la colonne d'index, il n'y aura pas de problèmes et on pourra continuer à utiliser <literal>mappedBy</literal> dans le mappage de collection :"
#. Tag: programlisting
#: Entity.xml:1238
@@ -5359,6 +5568,25 @@
" ...\n"
"}"
msgstr ""
+"@Entity\n"
+"public class Parent {\n"
+" @OneToMany(mappedBy=\"parent\")\n"
+" @org.hibernate.annotations.MapKey(columns=@Column(name=\"name\"))\n"
+" private Map<String, Child> children;\n"
+" ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Parent {\n"
+" ...\n"
+" @Basic\n"
+" private String name;\n"
+"\n"
+" @ManyToOne\n"
+" @JoinColumn(name=\"parent_id\", nullable=false)\n"
+" private Parent parent;\n"
+" ...\n"
+"}"
#. Tag: para
#: Entity.xml:1239
@@ -5369,7 +5597,7 @@
"one end of the association that is not available at the other end). In this "
"case, we can't map the collection <literal>mappedBy</literal>. Instead, "
"we could use the following mapping:"
-msgstr ""
+msgstr "Mais, s'il n'existe pas de propriété sur la classe d'un dépendant, on ne pourra pas imaginer l'association totalement bidirectionnelle (il y a des informations disponibles à l'une des extrémités de l'association, qui ne sont pas disponibles à l'autre). Dans ce cas, nous ne pouvons pas mapper la collection <literal>mappedBy</literal>. A la place, nous pouvons utiliser la mappage suivant :"
#. Tag: programlisting
#: Entity.xml:1242
@@ -5394,6 +5622,24 @@
" ...\n"
"}"
msgstr ""
+"@Entity\n"
+"public class Parent {\n"
+" @OneToMany\n"
+" @org.hibernate.annotations.MapKey(columns=@Column(name=\"name\"))\n"
+" @JoinColumn(name=\"parent_id\", nullable=false)\n"
+" private Map<String, Child> children;\n"
+" ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Parent {\n"
+" ...\n"
+" @ManyToOne\n"
+" @JoinColumn(name=\"parent_id\", insertable=false, updatable=false, "
+"nullable=false)\n"
+" private Parent parent;\n"
+" ...\n"
+"}"
#. Tag: para
#: Entity.xml:1243
@@ -5401,13 +5647,13 @@
msgid ""
"Note that in this mapping, the collection-valued end of the association is "
"responsible for updates to the foreign key."
-msgstr ""
+msgstr "Notez que dans ce mappage, l'extrêmité collection-valued de l'association est chargée des mises à jour de la clé étrangère."
#. Tag: title
#: Entity.xml:1246
#, no-c-format
msgid "Bag with primary key"
-msgstr ""
+msgstr "Bag et les clé primaires"
#. Tag: para
#: Entity.xml:1247
@@ -5422,7 +5668,7 @@
"allow to override the primary key column(s), the primary key type and the "
"generator strategy. The strategy can be <literal>identity</literal>, or any "
"defined generator name of your application."
-msgstr ""
+msgstr "Il existe uen autre fonctionnalité interessante : la possibilité de définir une clé primaire de susbstitution pour une collection bag. Cela supprime de nombreux inconvénients de bags : la mise à jour et la suppression sont efficaces, avec plus d'un bag <literal>EAGER</literal> par requête ou par entité. Cette clé primaire sera contenue dans une colonne supplémentaire de votre table de collection, mais ne sera pas visible par l'application java. @CollectionId est utilisé pour marquer une collection en tant qu'id bag. Cela vous permet également de surcharger la(les) colonne(s) de clés primaires, le type de clé primaire et la stratégie de generator. La stratégie peut être <literal>identity</literal>, ou n'importe quel nom de générateur déterminé pour votre application."
#. Tag: programlisting
#: Entity.xml:1250
@@ -5442,12 +5688,25 @@
" ...\n"
"}"
msgstr ""
+"@Entity\n"
+"@TableGenerator(name=\"ids_generator\", table=\"IDS\")\n"
+"public class Passport {\n"
+" ...\n"
+"\n"
+" @ManyToMany(cascade = CascadeType.ALL)\n"
+" @JoinTable(name=\"PASSPORT_VISASTAMP\")\n"
+" <emphasis role=\"bold\">@CollectionId( columns = @Column(name="
+"\"COLLECTION_ID\"), type=@Type(type=\"long\"),</emphasis>\n"
+" <emphasis role=\"bold\">generator = \"ids_generator\" )</emphasis>\n"
+" private Collection<Stamp> visaStamp = new ArrayList();\n"
+" ...\n"
+"}"
#. Tag: title
#: Entity.xml:1251
#, no-c-format
msgid "Collection of element or composite elements"
-msgstr ""
+msgstr "Collection d'éléments ou d'éléments composites"
#. Tag: para
#: Entity.xml:1252
@@ -5456,7 +5715,7 @@
"Hibernate Annotations also supports collections of core types (Integer, "
"String, Enums, ...), collections of embeddable objects and even arrays of "
"primitive types. This is known as collection of elements."
-msgstr ""
+msgstr "Hibernate Annotations supporte également des collections de type principaux (Integer, String, Enums, ...), des collections d'objets imbriquables et même des tables de type primitif. Cela est compris comme une collection d'éléments."
#. Tag: para
#: Entity.xml:1255
@@ -5478,6 +5737,9 @@
"embeddable element). To reach the index/key of a collection, append \"key\" "
"instead."
msgstr ""
+"Une collection d'éléments doit être annotée en tant que <literal>@CollectionOfElements</literal> (en tant que remplacement de "
+"<literal>@OneToMany</literal>) Pour définir la table de collection, l'annotation "
+"<literal>@JoinTable</literal> est utilisée sur la propriété d'association, <literal>joinColumns</literal> définit les colonnes jointes entre la table primaire d'entité et la table de collection (inverseJioncolumn est inutile et doit rester vide). Pour collection des types principaux, ou des tables de type primitif, vous pourrez surcharger l'élément définition de colonne en utilisant un <literal>@Column</literal> sur la propriété de l'association. Vous pourrez également surcharger les colonnes d'une collection d'objets imbriquables en utilisant <literal>@AttributeOverride</literal>. Pour atteindre l'élément de collection, vous aurez besoin d'annexer \"element\" au nom de surcharge de l'attribut ( par exemple \"element\" pour les types principaux\", ou \"element.serial\" pour la propriété en série d'un élément imbriquable). Pour atteindre l'index/la clé d'une collection, annexez \"key\" à la place."
#. Tag: programlisting
#: Entity.xml:1258
@@ -5587,6 +5849,109 @@
" }\n"
"}"
msgstr ""
+"@Entity\n"
+"public class Boy {\n"
+" private Integer id;\n"
+" private Set<String> nickNames = new HashSet<String>();\n"
+" private int[] favoriteNumbers;\n"
+" private Set<Toy> favoriteToys = new HashSet<Toy>();\n"
+" private Set<Character> characters = new HashSet<Character>"
+"();\n"
+"\n"
+" @Id @GeneratedValue\n"
+" public Integer getId() {\n"
+" return id;\n"
+" }\n"
+"\n"
+" <emphasis role=\"bold\">@CollectionOfElements public Set<String></"
+"emphasis> getNickNames() {\n"
+" return nickNames;\n"
+" }\n"
+"\n"
+" <emphasis role=\"bold\">@CollectionOfElements @JoinTable( table=@Table"
+"(name=\"BoyFavoriteNumbers\"), </emphasis>\n"
+" <emphasis role=\"bold\">joinColumns = @JoinColumn(name=\"BoyId\") ) "
+"@Column(name=\"favoriteNumber\",</emphasis> \n"
+" <emphasis role=\"bold\">nullable=false)</emphasis>\n"
+" @IndexColumn(name=\"nbr_index\")\n"
+" public int[] getFavoriteNumbers() {\n"
+" return favoriteNumbers;\n"
+" }\n"
+"\n"
+" <emphasis role=\"bold\">@CollectionOfElements @AttributeOverride( name="
+"\"element.serial\",</emphasis>\n"
+" <emphasis role=\"bold\">column=@Column(name=\"serial_nbr\") )</"
+"emphasis>\n"
+" public Set<Toy> getFavoriteToys() {\n"
+" return favoriteToys;\n"
+" }\n"
+"\n"
+" <emphasis role=\"bold\">@CollectionOfElements public Set<Character>"
+"</emphasis> getCharacters() {\n"
+" return characters;\n"
+" }\n"
+" ...\n"
+"}\n"
+"\n"
+"public enum Character {\n"
+" GENTLE,\n"
+" NORMAL,\n"
+" AGGRESSIVE,\n"
+" ATTENTIVE,\n"
+" VIOLENT,\n"
+" CRAFTY\n"
+"}\n"
+"\n"
+"@Embeddable\n"
+"public class Toy {\n"
+" public String name;\n"
+" public String serial;\n"
+" public Boy owner;\n"
+"\n"
+" public String getName() {\n"
+" return name;\n"
+" }\n"
+"\n"
+" public void setName(String name) {\n"
+" this.name = name;\n"
+" }\n"
+"\n"
+" public String getSerial() {\n"
+" return serial;\n"
+" }\n"
+"\n"
+" public void setSerial(String serial) {\n"
+" this.serial = serial;\n"
+" }\n"
+"\n"
+" <emphasis role=\"bold\">@Parent</emphasis>\n"
+" public Boy getOwner() {\n"
+" return owner;\n"
+" }\n"
+"\n"
+" public void setOwner(Boy owner) {\n"
+" this.owner = owner;\n"
+" }\n"
+"\n"
+" public boolean equals(Object o) {\n"
+" if ( this == o ) return true;\n"
+" if ( o == null || getClass() != o.getClass() ) return false;\n"
+"\n"
+" final Toy toy = (Toy) o;\n"
+"\n"
+" if ( !name.equals( toy.name ) ) return false;\n"
+" if ( !serial.equals( toy.serial ) ) return false;\n"
+"\n"
+" return true;\n"
+" }\n"
+"\n"
+" public int hashCode() {\n"
+" int result;\n"
+" result = name.hashCode();\n"
+" result = 29 * result + serial.hashCode();\n"
+" return result;\n"
+" }\n"
+"}"
#. Tag: para
#: Entity.xml:1259
@@ -5595,7 +5960,7 @@
"On a collection of embeddable objects, the embeddable object can have a "
"property annotated with <literal>@Parent</literal>. This property will then "
"point back to the entity containing the collection."
-msgstr ""
+msgstr "Dans une collection d'objets imbriquables, l'objet imbriquable peut avoir une propriété annoté avec <literal>@Parent</literal>. Cette propriété pointera ensuite vers l'entité qui contient la collection."
#. Tag: para
#: Entity.xml:1263
@@ -5607,12 +5972,14 @@
"literal>. Marking collections of elements the old way still work but is "
"considered deprecated and is going to be unsupported in future releases"
msgstr ""
+"Des anciennes versions d'Hibernate Annotations utilisaient <literal>@OneToMany</literal> pour marquer une collection d'éléments. En raison d'inconsistences sémantiques, nous avons introduit l'annotation <literal>@CollectionOfElements</"
+"literal>. On peut toujours marquer les éléments par l'ancienne méthode, mais cette méthode est considérée comme obsolète et ne sera plus prise en charge dans les versions à venir."
#. Tag: title
#: Entity.xml:1267
#, no-c-format
msgid "Cache"
-msgstr ""
+msgstr "Cache"
#. Tag: para
#: Entity.xml:1268
@@ -5621,7 +5988,7 @@
"In order to optimize your database accesses, you can activave the so called "
"second level cache of Hibernate. This cache is configurable on a per entity "
"and per collection basis."
-msgstr ""
+msgstr "Pour pouvoir optimiser les accès à votre base de données, vous pouvez activer le second niveau cache, comme il est nommé, d'Hibernate. Ce cache est configurable sur la base d'une entité et d'uen collection."
#. Tag: para
#: Entity.xml:1271
@@ -5630,7 +5997,7 @@
"<literal>@org.hibernate.annotations.Cache</literal> defines the caching "
"strategy and region of a given second level cache. This annotation can be "
"applied on the root entity (not the sub entities), and on the collections."
-msgstr ""
+msgstr "<literal>@org.hibernate.annotations.Cache</literal> détermine la stratégie de caching de la région d'un cache de second niveau donné. Cette annotation peut être appliquée sur l'entité root (pas sur les sous-entrées), et sur les collections."
#. Tag: programlisting
#: Entity.xml:1274
@@ -5640,6 +6007,9 @@
"@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)\n"
"public class Forest { ... }"
msgstr ""
+"@Entity\n"
+"@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)\n"
+"public class Forest { ... }"
#. Tag: programlisting
#: Entity.xml:1275
@@ -5652,6 +6022,12 @@
" return tickets;\n"
" }"
msgstr ""
+"@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)\n"
+" @JoinColumn(name=\"CUST_ID\")\n"
+" @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)\n"
+" public SortedSet<Ticket> getTickets() {\n"
+" return tickets;\n"
+" }"
#. Tag: programlisting
#: Entity.xml:1282
@@ -5663,6 +6039,11 @@
" String include() default \"all\";\n"
")"
msgstr ""
+"@Cache(\n"
+" CacheConcurrencyStrategy usage();\n"
+" String region() default \"\";\n"
+" String include() default \"all\";\n"
+")"
#. Tag: para
#: Entity.xml:1285
@@ -5671,6 +6052,8 @@
"usage: the given cache concurrency strategy (NONE, READ_ONLY, "
"NONSTRICT_READ_WRITE, READ_WRITE, TRANSACTIONAL)"
msgstr ""
+"usage: la stratégie de concurence d'un cache donné (NONE, READ_ONLY, "
+"NONSTRICT_READ_WRITE, READ_WRITE, TRANSACTIONAL)"
#. Tag: para
#: Entity.xml:1290
@@ -5678,7 +6061,7 @@
msgid ""
"region (optional): the cache region (default to the fqcn of the class or the "
"fq role name of the collection)"
-msgstr ""
+msgstr "région (optionnel) : la région cache (par défaut le FQCN de la classe ou le nom de role FQ de la collection)"
#. Tag: para
#: Entity.xml:1295
@@ -5686,13 +6069,13 @@
msgid ""
"<literal>include</literal> (optional): all to include all properties, non-"
"lazy to only include non lazy properties (default all)."
-msgstr ""
+msgstr "<literal>include</literal> (optionnel): all pour inclure toutes les propriétés, non lazy pour n'inclure que les propriétés non lazy (valeur par défaut : all)"
#. Tag: title
#: Entity.xml:1302
#, no-c-format
msgid "Filters"
-msgstr ""
+msgstr "Filtres"
#. Tag: para
#: Entity.xml:1303
@@ -5701,7 +6084,7 @@
"Hibernate has the ability to apply arbitrary filters on top of your data. "
"Those filters are applied at runtime on a given session. First, you need to "
"define them."
-msgstr ""
+msgstr "Hibernate a la possibilité d'appliquer des filtres arbitraires sur vos données. Ces filtres sont appliqués en cours d'exécution d'une session donnée. Vous devrez tout d'abord les définir."
#. Tag: para
#: Entity.xml:1306
@@ -5742,6 +6125,15 @@
"} )\n"
"public class Forest { ... }"
msgstr ""
+"@Entity\n"
+"@FilterDef(name=\"minLength\", parameters={ @ParamDef( name=\"minLength\", "
+"type=\"integer\" ) } )\n"
+"@Filters( {\n"
+" @Filter(name=\"betweenLength\", condition=\":minLength <= length and :"
+"maxLength >= length\"),\n"
+" @Filter(name=\"minLength\", condition=\":minLength <= length\")\n"
+"} )\n"
+"public class Forest { ... }"
#. Tag: para
#: Entity.xml:1315
@@ -5769,12 +6161,21 @@
"requredLevel\")\n"
" public Set<Forest> getForests() { ... }"
msgstr ""
+"@OneToMany\n"
+" @JoinTable\n"
+" //filter on the target entity table\n"
+" @Filter(name=\"betweenLength\", condition=\":minLength <= length and :"
+"maxLength >= length\")\n"
+" //filter on the association table\n"
+" @FilterJoinTable(name=\"security\", condition=\":userlevel >= "
+"requredLevel\")\n"
+" public Set<Forest> getForests() { ... }"
#. Tag: title
#: Entity.xml:1319
#, no-c-format
msgid "Queries"
-msgstr ""
+msgstr "Requêtes"
#. Tag: para
#: Entity.xml:1320
@@ -5793,7 +6194,7 @@
#: Entity.xml:1325
#, no-c-format
msgid "flushMode: define the query flush mode (Always, Auto, Commit or Never)"
-msgstr ""
+msgstr "flushMode : détermine le mode flush de la requête (Always, Auto, Commit ou Never)"
#. Tag: para
#: Entity.xml:1330
@@ -5817,13 +6218,13 @@
#: Entity.xml:1345
#, no-c-format
msgid "timeout: query time out"
-msgstr ""
+msgstr "timeout : délai de recherche"
#. Tag: para
#: Entity.xml:1350
#, no-c-format
msgid "callable: for native queries only, to be set to true for stored procedures"
-msgstr ""
+msgstr "callable : pour les recherches native uniquement, à fixer à true pour les procédures stockées"
#. Tag: para
#: Entity.xml:1355
@@ -5831,13 +6232,13 @@
msgid ""
"comment: if comments are activated, the comment seen when the query is sent "
"to the database."
-msgstr ""
+msgstr "comment : si les commentaires sont activés, le commentaire que l'on voit quand la demande est envoyée vers la base de données."
#. Tag: para
#: Entity.xml:1360
#, no-c-format
msgid "cacheMode: Cache interaction mode (get, ignore, normal, put or refresh)"
-msgstr ""
+msgstr "cacheMode : mode d'interaction cache (get, ignore, normal, put ou refresh)"
#. Tag: para
#: Entity.xml:1365
@@ -5845,7 +6246,7 @@
msgid ""
"readOnly: whether or not the elements retrievent from the query are in read "
"only mode."
-msgstr ""
+msgstr "readOnly : si les éléments extraits suite à la demande sont en mode lecture-seule."
#. Tag: para
#: Entity.xml:1370
@@ -5856,12 +6257,14 @@
"Another key advantage is the ability to set those annotations at a package "
"level."
msgstr ""
+"Ces éléments pourront être fixés dans un annotation standard <literal>@javax.persistence.NamedQuery</"
+"literal> par <literal>@QueryHint</literal> détypé. Un autre avantage est que l'on peut fixer ces annotations au niveau du package."
#. Tag: title
#: Entity.xml:1373
#, no-c-format
msgid "Custom SQL for CRUD operations"
-msgstr ""
+msgstr "Personnaliser SQL pour les opérations CRUD"
#. Tag: para
#: Entity.xml:1374
@@ -5870,7 +6273,7 @@
"Hibernate gives you the avility to override every single SQL statement "
"generated. We have seen native SQL query usage already, but you can also "
"override the SQL statement used to load or change the state of entities."
-msgstr ""
+msgstr "Hibernate vous donne la possibilité de surcharger chaque énoncé SQL généré. Nous avons déjà vu l'utilisation des requêtes SQL natives, mais vous pouvez aussi surcharger l'énoncé SQL qui est utilisé pour charger ou pour changer l'état des entités."
#. Tag: programlisting
#: Entity.xml:1377
@@ -5896,6 +6299,25 @@
" private String name;\n"
" private String nickname;"
msgstr ""
+"@Entity\n"
+"@Table(name=\"CHAOS\")\n"
+" <emphasis role=\"bold\">@SQLInsert( sql=\"INSERT INTO CHAOS(size, "
+"name, nickname, id)</emphasis>\n"
+" <emphasis role=\"bold\">VALUES(?,upper(?),?,?)\") @SQLUpdate( sql="
+"\"UPDATE CHAOS SET size = ?, name = upper(?),</emphasis>\n"
+" <emphasis role=\"bold\">nickname = ? WHERE id = ?\")</emphasis> \n"
+" <emphasis role=\"bold\">@SQLDelete( sql=\"DELETE CHAOS WHERE id = ?"
+"\") @SQLDeleteAll( sql=\"DELETE CHAOS\") </emphasis>\n"
+" <emphasis role=\"bold\">@Loader(namedQuery = \"chaos\")</emphasis>\n"
+"@NamedNativeQuery(name=\"chaos\", query=\"select id, size, name, lower"
+"( nickname )\n"
+"as nickname from CHAOS where id= ?\", resultClass = Chaos.class)\n"
+"public class Chaos {\n"
+" @Id\n"
+" private Long id;\n"
+" private Long size;\n"
+" private String name;\n"
+" private String nickname;"
#. Tag: para
#: Entity.xml:1378
@@ -5906,6 +6328,8 @@
"override the INSERT statement, UPDATE statement, DELETE statement, DELETE "
"statement to remove all entities."
msgstr ""
+"<literal>@SQLInsert</literal>, <literal>@SQLUpdate</literal>, "
+"<literal>@SQLDelete</literal>, <literal>@SQLDeleteAll</literal> surchargent respectivement l'énoncé INSERT, l'énoncé UPDATE, l'énoncé DELETE et DELETE pour supprimer toutes les entités."
#. Tag: para
#: Entity.xml:1381
@@ -5915,6 +6339,8 @@
"<literal>callable</literal> attribute to true (<literal>@SQLInsert"
"(callable=true, ...)</literal>)."
msgstr ""
+"SI vous pensez appeler une procédure de stockage, veillez à bien fixer l'attribut <literal>callable</literal> à true (<literal>@SQLInsert"
+"(callable=true, ...)</literal>)."
#. Tag: para
#: Entity.xml:1384
@@ -5922,7 +6348,7 @@
msgid ""
"To check that the execution happens correctly, Hibernate allows you to "
"define one of those three strategies:"
-msgstr ""
+msgstr "Pour vérifier que l'exécution ait lieu correctement, Hibernate vous permet de définir une de ces trois sratégies :"
#. Tag: para
#: Entity.xml:1389
@@ -5930,13 +6356,13 @@
msgid ""
"NONE: no check is performed: the store procedure is expected to fail upon "
"issues"
-msgstr ""
+msgstr "NONE : pas de vérification : la procédure de stockage risque d'échouer à cause de problèmes"
#. Tag: para
#: Entity.xml:1394
#, no-c-format
msgid "COUNT: use of rowcount to check that the update is successful"
-msgstr ""
+msgstr "COUNT : utilisation ddu comptage des rangées pour vérifier que la mise à jour a bien fonctionné."
#. Tag: para
#: Entity.xml:1399
@@ -5944,7 +6370,7 @@
msgid ""
"PARAM: like COUNT but using an output parameter rather that the standard "
"mechanism"
-msgstr ""
+msgstr "PARAM : comme COUNT mais en utilisant un paramètre de sortie plutôt qu'un mécanisme standard."
#. Tag: para
#: Entity.xml:1404
@@ -5953,6 +6379,8 @@
"To define the result check style, use the <literal>check</literal> parameter "
"(<literal>@SQLUpdate(check=ResultCheckStyle.COUNT, ...)</literal>)."
msgstr ""
+"Pour définir le style de vérification des résultats, utilisez le paramètre <literal>check</literal> "
+"(<literal>@SQLUpdate(check=ResultCheckStyle.COUNT, ...)</literal>)."
#. Tag: para
#: Entity.xml:1407
@@ -5961,7 +6389,7 @@
"You can also override the SQL load statement by a native SQL query or a HQL "
"query. You just have to refer to a named query with the "
"<literal><literal>@Loader</literal></literal> annotation."
-msgstr ""
+msgstr "Vous pouvez également surcharger l'énoncé de chargement SQL par une requête SQL ou une requête HQL. Vous avez juste à vous reporter à une requête intitulée contenant l'annotation <literal><literal>@Loader</literal></literal>."
#. Tag: para
#: Entity.xml:1410
@@ -5969,7 +6397,7 @@
msgid ""
"You can use the exact same set of annotations to override the collection "
"related statements."
-msgstr ""
+msgstr "Vous pouvez utiliser exactement le me groupe d'annotations pour surcharger les énoncés liés à la collection."
#. Tag: programlisting
#: Entity.xml:1413
@@ -5984,6 +6412,14 @@
"private Set<CasimirParticle> particles = new HashSet<"
"CasimirParticle>();"
msgstr ""
+"@OneToMany\n"
+"@JoinColumn(name=\"chaos_fk\")\n"
+" <emphasis role=\"bold\">@SQLInsert( sql=\"UPDATE CASIMIR_PARTICULE "
+"SET chaos_fk = ? where id = ?\")</emphasis>\n"
+" <emphasis role=\"bold\">@SQLDelete( sql=\"UPDATE CASIMIR_PARTICULE "
+"SET chaos_fk = null where id = ?\")</emphasis>\n"
+"private Set<CasimirParticle> particles = new HashSet<"
+"CasimirParticle>();"
#. Tag: para
#: Entity.xml:1414
@@ -5996,5 +6432,5 @@
"create, update, delete etc. entities. (To see the expected sequence, "
"remember to not include your custom SQL through annotations as that will "
"override the Hibernate generated static sql.)"
-msgstr ""
+msgstr "L'ordre des paramètres des important et est déterminé par la façon dont Hibernate gère les propriétés. Vous pourrez apercevoir l'ordre en activant la journalisation de déboggage pour au niveau <literal>org.hibernate.persister.entity</literal>. Une fois ce niveau activé, Hibernate imprimera le SQL static qui est utilisé pour créer, mettre à jour et supprimer etc. les entités. (Pour en voir les conséquences prévues, souvenez-vous de ne pas inclure votre SQL personnalisé par des annotations car cela surchargerait le static sql généré par Hibernate)"
More information about the jboss-cvs-commits
mailing list