[jboss-cvs] JBossAS SVN: r88852 - projects/docs/enterprise/4.3.3/Hibernate/Annotations_Reference_Guide/fr-FR.

[jboss-cvs-commits at lists.jboss.org]

Author: croe at redhat.com
Date: 2009-05-14 02:28:03 -0400 (Thu, 14 May 2009)
New Revision: 88852

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-14 06:22:05 UTC (rev 88851)
+++ projects/docs/enterprise/4.3.3/Hibernate/Annotations_Reference_Guide/fr-FR/Entity.po	2009-05-14 06:28:03 UTC (rev 88852)
@@ -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-13 16:13+1000\n"
+"PO-Revision-Date: 2009-05-14 16:23+1000\n"
 "Last-Translator: Corina Roe <croe at redhat.com>\n"
 "Language-Team: French <i18 at redhat.com>\n"
 "MIME-Version: 1.0\n"
@@ -1478,7 +1478,7 @@
 "Consequently, when using this strategy, you should not use <literal>AUTO </"
 "literal>nor <literal>IDENTITY</literal>."
 msgstr ""
-"Cette sratégie supporte les associations one to many, dans la mesure où elles sont bidirectionnelles. Cette stratégie ne supporte pas la stratégie de générateur <literal>IDENTITY</"
+"Cette stratégie supporte les associations one to many, dans la mesure où elles sont bidirectionnelles. Cette stratégie ne supporte pas la stratégie de générateur <literal>IDENTITY</"
 "literal> : l'id doit être partagée parmi plusieurs tables. De ce fait, quand vous utilisez cette stratégie, vous ne devriez pas utiliser <literal>AUTO </"
 "literal>ni <literal>IDENTITY</literal>."
 
@@ -1543,6 +1543,8 @@
 "only have to define discriminator value if you don&#39;t want to use the "
 "default value. The strategy and the discriminator type are implicit."
 msgstr ""
+"<classname>Plane</classname> est la superclasse, elle détermine la stratégie de transmission de données <literal>InheritanceType.SINGLE_TABLE</literal>. Cela détemine également la colonne discriminator par l'annotation <literal>@DiscriminatorColumn</literal>, une colonne discriminator peut également déterminer le type de discriminator. Finalement, l'annotation <literal>@DiscriminatorValue</literal> détermine la valeur utilisée pour différencier une classe dans la hiérarchie. Tous ces attributs ont des valeurs par défaut raisonnables. Le nom par défaut de la colonne discriminator est <literal>DTYPE</literal>. La valeur du discriminant par défaut est le nom de l'entité (comme définie dans <literal>@Entity.name</literal>) pour "
+"DiscriminatorType.STRING. <classname>A320</classname> est une sous-classe; vous n'aurez qu'à déterminer la valeur du discrimant si vous souhaitez utiliser la valeur par défaut. La stratéfie et le type de discriminant sont implicites."
 
 #. Tag: para
 #: Entity.xml:380
@@ -1551,12 +1553,14 @@
 "<literal>@Inheritance</literal> and <literal>@DiscriminatorColumn</literal> "
 "should only be defined at the top of the entity hierarchy."
 msgstr ""
+"<literal>@Inheritance</literal> et <literal>@DiscriminatorColumn</literal> "
+"doivent seulement être définis en haut de la hiérarchie de l'entité."
 
 #. Tag: title
 #: Entity.xml:383
 #, no-c-format
 msgid "Joined subclasses"
-msgstr ""
+msgstr "Sous-classes jointes"
 
 #. Tag: para
 #: Entity.xml:384
@@ -1566,6 +1570,8 @@
 "<literal>@PrimaryKeyJoinColumns</literal> annotations define the primary key"
 "(s) of the joined subclass table:"
 msgstr ""
+"Les annotations <literal> @PrimaryKeyJoinColumn</literal> et "
+"<literal>@PrimaryKeyJoinColumns</literal> définissent la(les) clé(s) primaire(s) de la table de sous-classe jointe :"
 
 #. Tag: programlisting
 #: Entity.xml:387
@@ -1582,6 +1588,16 @@
 "@PrimaryKeyJoinColumn(name=\"BOAT_ID\")\n"
 "public class AmericaCupClass  extends Boat { ... }"
 msgstr ""
+"@Entity\n"
+"@Inheritance(strategy=InheritanceType.JOINED)\n"
+"public class Boat implements Serializable { ... }\n"
+"\n"
+"@Entity\n"
+"public class Ferry extends Boat { ... }\n"
+"\n"
+"@Entity\n"
+"@PrimaryKeyJoinColumn(name=\"BOAT_ID\")\n"
+"public class AmericaCupClass  extends Boat { ... }"
 
 #. Tag: para
 #: Entity.xml:388
@@ -1593,12 +1609,14 @@
 "literal> table is joined with <literal>Boat</literal> using the join "
 "condition <code>Boat.id = AmericaCupClass.BOAT_ID</code>."
 msgstr ""
+"Toutes les entités ci-dessus utilisent la stratégie <literal>JOINED</literal>, la table <literal>Ferry</literal> est jointe avec la table <literal>Boat</literal>, en utilisant les mêmes noms de clé primaires. La table <literal>AmericaCupClass</"
+"literal> est jointe avec <literal>Boat</literal> en utilisant la condition de jointure <code>Boat.id = AmericaCupClass.BOAT_ID</code>."
 
 #. Tag: title
 #: Entity.xml:391
 #, no-c-format
 msgid "Inherit properties from superclasses"
-msgstr ""
+msgstr "Hérite les propriétés des superclasses"
 
 #. Tag: para
 #: Entity.xml:392
@@ -1608,7 +1626,7 @@
 "business superclass without including it as a regular mapped entity (ie no "
 "specific table for this entity). For that purpose you can map them as "
 "<literal>@MappedSuperclass</literal>."
-msgstr ""
+msgstr "Il est utile de partager des propriétés communes à travers une superclasse commerciale ou technique sans pour autant l'inclure en tant qu'entité mappée habituelle (c'est à dire pas de table spécifique pour cette entité). Dans ce but, vous pouvez les mapper en tant que <literal>@MappedSuperclass</literal>."
 
 #. Tag: programlisting
 #: Entity.xml:395
@@ -1628,6 +1646,19 @@
 "    ...\n"
 "}"
 msgstr ""
+"@MappedSuperclass\n"
+"public class BaseEntity {\n"
+"    @Basic\n"
+"    @Temporal(TemporalType.TIMESTAMP)\n"
+"    public Date getLastUpdate() { ... }\n"
+"    public String getLastUpdater() { ... }\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity class Order extends BaseEntity {\n"
+"    @Id public Integer getId() { ... }\n"
+"    ...\n"
+"}"
 
 #. Tag: para
 #: Entity.xml:396
@@ -1639,6 +1670,9 @@
 "property mappings are copied into their entity subclasses. Remember that the "
 "embeddable superclass is not the root of the hierarchy though."
 msgstr ""
+"Dans la base de données, cette hiérarchie sera représentée en tant que table <literal>Order</"
+"literal> avec les colonnes <literal>id</literal>, <literal>lastUpdate</"
+"literal> et <literal>lastUpdater</literal>. Les mappages de propriétés de superclasses intégrées sont copiées dans leurs sous-classes d'entité. Souvenez-vous que la superclasse intégrée n'est cependant pas à la base de la hiérarchie."
 
 #. Tag: para
 #: Entity.xml:400
@@ -1647,6 +1681,8 @@
 "Properties from superclasses not mapped as <literal>@MappedSuperclass</"
 "literal> are ignored."
 msgstr ""
+"Les propriétés de superclasses qui ne sont pas mappées en tant que <literal>@MappedSuperclass</"
+"literal> ne sont pas prises en considération."
 
 #. Tag: para
 #: Entity.xml:405
@@ -1654,7 +1690,7 @@
 msgid ""
 "The access type (field or methods), is inherited from the root entity, "
 "unless you use the Hibernate annotation <literal>@AccessType</literal>"
-msgstr ""
+msgstr "Le type d'accès (champ ou méthode), est hérité de l'entité root, à moins que vous utilisiez l'annotation Hibernate <literal>@AccessType</literal>"
 
 #. Tag: para
 #: Entity.xml:410
@@ -1664,7 +1700,7 @@
 "persist properties from their superclasses. You also need to use "
 "<literal>@MappedSuperclass</literal> to do that (this should not be "
 "considered as a standard EJB3 feature though)"
-msgstr ""
+msgstr "La même notion peut s'appliquer aux objets <literal>@Embeddable</literal> pour persister les propriétés à partir de leurs superclasses. Vous aurez également besoin d'utiliser <literal>@MappedSuperclass</literal> pour cela (mais cela ne doit pas représenter une fonctionnalité EJB3 standard)"
 
 #. Tag: para
 #: Entity.xml:415
@@ -1672,7 +1708,7 @@
 msgid ""
 "It is allowed to mark a class as <literal>@MappedSuperclass</literal> in the "
 "middle of the mapped inheritance hierarchy."
-msgstr ""
+msgstr "Il est autorisé de marquer une classe en tant que <literal>@MappedSuperclass</literal> au milieu de la hiérarchie d'héritage mappée."
 
 #. Tag: para
 #: Entity.xml:420
@@ -1681,6 +1717,8 @@
 "Any class in the hierarchy non annotated with <literal>@MappedSuperclass</"
 "literal> nor <literal>@Entity</literal> will be ignored."
 msgstr ""
+"Toute classe de la hiérarchie qui ne serait pas annotée avec <literal>@MappedSuperclass</"
+"literal> ou <literal>@Entity</literal> sera ignorée."
 
 #. Tag: para
 #: Entity.xml:424
@@ -1688,7 +1726,7 @@
 msgid ""
 "You can override columns defined in entity superclasses at the root entity "
 "level using the <literal>@AttributeOverride</literal> annotation."
-msgstr ""
+msgstr "Vous pouvez surcharger les colonnes définies en tant que superclasses d'entités au niveau entité root, en utilisant l'annotation <literal>@AttributeOverride</literal>."
 
 #. Tag: programlisting
 #: Entity.xml:427
@@ -1722,6 +1760,33 @@
 "    ...\n"
 "}"
 msgstr ""
+"@MappedSuperclass\n"
+"public class FlyingObject implements Serializable {\n"
+"\n"
+"    public int getAltitude() {\n"
+"        return altitude;\n"
+"    }\n"
+"\n"
+"    @Transient\n"
+"    public int getMetricAltitude() {\n"
+"        return metricAltitude;\n"
+"    }\n"
+"\n"
+"    @ManyToOne\n"
+"    public PropulsionType getPropulsion() {\n"
+"        return metricAltitude;\n"
+"    }\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"@AttributeOverride( name=\"altitude\", column = @Column(name=\"fld_altitude"
+"\") )\n"
+"@AssociationOverride( name=\"propulsion\", joinColumns = @JoinColumn(name="
+"\"fld_propulsion_fk\") )\n"
+"public class Plane extends FlyingObject {\n"
+"    ...\n"
+"}"
 
 #. Tag: para
 #: Entity.xml:428
@@ -1731,7 +1796,7 @@
 "<literal>fld_altitude</literal> column of table <literal>Plane</literal> and "
 "the propulsion association will be materialized in a "
 "<literal>fld_propulsion_fk</literal> foreign key column."
-msgstr ""
+msgstr "La propriété <literal>altitude</literal> sera persistée dans une colonne <literal>fld_altitude</literal> de table <literal>Plane</literal> et l'association propulsion sera matérialisée dans une colonne de clé étrangère <literal>fld_propulsion_fk</literal>."
 
 #. Tag: para
 #: Entity.xml:431
@@ -1742,18 +1807,20 @@
 "classes, <literal>@MappedSuperclass</literal> classes and properties "
 "pointing to an <literal>@Embeddable</literal> object."
 msgstr ""
+"Vous pouvez déterminer <literal>@AttributeOverride</literal>(s) et "
+"<literal>@AssociationOverride</literal>(s) sur les classes et propriétés <literal>@Entity</literal>, <literal>@MappedSuperclass</literal> pointant sur un objet <literal>@Embeddable</literal>."
 
 #. Tag: title
 #: Entity.xml:434
 #, no-c-format
 msgid "Mapping entity bean associations/relationships"
-msgstr ""
+msgstr "Mappage des associations/relations des beans d'entité"
 
 #. Tag: title
 #: Entity.xml:435
 #, no-c-format
 msgid "One-to-one"
-msgstr ""
+msgstr "One-to-one"
 
 #. Tag: para
 #: Entity.xml:436
@@ -1767,13 +1834,13 @@
 "multiplicity), or a association table is used to store the link between the "
 "2 entities (a unique constraint has to be defined on each fk to ensure the "
 "one to one multiplicity)"
-msgstr ""
+msgstr "Vous pouvez associer les beans d'entité par la relation one-to-one en utilisant <literal>@OneToOne</literal>. Il existe trois cas pour les associations one-to-one : soit les entités associées partagent les mêmes valeurs de clés primaires, et une clé étrangère est détenue par un des entités (notez que la colonne FK de la base de données doit être contenue uniquement dans le but de simuler la multiplicité one-to-one), ou bien, une table d'associations est utilisée pour stocker le lien entre les deux entités (une contrainte unique doit être définie par chaque fk pour assurer la multiplicité one-to-one)"
 
 #. Tag: para
 #: Entity.xml:439
 #, no-c-format
 msgid "First, we map a real one-to-one association using shared primary keys:"
-msgstr ""
+msgstr "Tout d'abord, on mappe une véritable association one-to-one en utilisant les clés primaires partagées :"
 
 #. Tag: programlisting
 #: Entity.xml:442
@@ -1792,6 +1859,18 @@
 "    ...\n"
 "}"
 msgstr ""
+"@Entity\n"
+"public class Body {\n"
+"    @Id\n"
+"    public Long getId() { return id; }\n"
+"\n"
+"    @OneToOne(cascade = CascadeType.ALL)\n"
+"    @PrimaryKeyJoinColumn\n"
+"    public Heart getHeart() {\n"
+"        return heart;\n"
+"    }\n"
+"    ...\n"
+"}"
 
 #. Tag: programlisting
 #: Entity.xml:443
@@ -1803,6 +1882,11 @@
 "    public Long getId() { ...}\n"
 "}"
 msgstr ""
+"@Entity\n"
+"public class Heart {\n"
+"    @Id\n"
+"    public Long getId() { ...}\n"
+"}"
 
 #. Tag: para
 #: Entity.xml:444
@@ -1810,7 +1894,7 @@
 msgid ""
 "The one to one is marked as true by using the "
 "<literal>@PrimaryKeyJoinColumn</literal> annotation."
-msgstr ""
+msgstr "One-to-one est marqué en tant que true en utilisant l'annotation <literal>@PrimaryKeyJoinColumn</literal>."
 
 #. Tag: para
 #: Entity.xml:447
@@ -1818,7 +1902,7 @@
 msgid ""
 "In the following example, the associated entities are linked through a "
 "foreign key column:"
-msgstr ""
+msgstr "Dans l'exemple suivant, les entités associées sonts liées par une colonne de clé étrangère :"
 
 #. Tag: programlisting
 #: Entity.xml:450
@@ -1839,6 +1923,20 @@
 "    ...\n"
 "}"
 msgstr ""
+"@Entity\n"
+"public class Customer implements Serializable {\n"
+"    @OneToOne(cascade = CascadeType.ALL)\n"
+"    <emphasis role=\"bold\">@JoinColumn(name=\"passport_fk\")</emphasis>\n"
+"    public Passport getPassport() {\n"
+"        ...\n"
+"    }\n"
+"\n"
+"@Entity\n"
+"public class Passport implements Serializable {\n"
+"    @OneToOne(<emphasis role=\"bold\">mappedBy = \"passport\"</emphasis>)\n"
+"    public Customer getOwner() {\n"
+"    ...\n"
+"}"
 
 #. Tag: para
 #: Entity.xml:451
@@ -1857,6 +1955,14 @@
 "literal></literal> to a non primary key column has to be mapped to a "
 "property having a single column (other cases might not work)."
 msgstr ""
+"Un <classname>Customer</classname> est lié à un <classname>Passport</"
+"classname>, par une colonne de clé étrangère nommée <literal>passport_fk</literal> "
+"dans la table <literal>Customer</literal>. La colonne de jointure est déclarée avec l'annotation <literal>@JoinColumn</literal> qui ressemble à l'annotation "
+"<literal>@Column</literal>. Elle comporte un paramètre supplémentaire nommé "
+"<literal>referencedColumnName</literal>. Ce paramètre déclare la colonne dans l'entité cible, qui va être utilisée pour la jointure. Notez que quand on utilise "
+"<literal><literal>referencedColumnName</literal></literal> pour une colonne clé non-primaires, la classe associée devra être <classname>Serializable</"
+"classname>. Aussi, notez que le <literal><literal>referencedColumnName</"
+"literal></literal> d'une colonne de clés primaires devra être mappé à une propriété possédant une simple colonne (ne fonctionnera pas forcément dans les autres cas)."
 
 #. Tag: para
 #: Entity.xml:454
@@ -1871,6 +1977,8 @@
 "literal>. As you can see, you don&#39;t have to (must not) declare the join "
 "column since it has already been declared on the owners side."
 msgstr ""
+"L'association peut être bidirectionnelle. Dans une relation bidirectionnelle, l'une des parties (et une partie seulement) devra être propriétaire : le propriétaire est responsable pour la mise à jour de colonne(s) d'association. Pour déclarer une partie comme <emphasis>non</emphasis> responsable de la relation, l'attribut <literal>mappedBy</literal> est utilisé. <literal>mappedBy</literal> se rapporte au nom de la propriété de l'association du côté client. Dans notre cas, il s'agit de <literal>passport</"
+"literal>. Comme vous pourrez remarquer, vous ne devez (surtout) pas déclarer la colonne de jointure car elle aura déjà été déclarée du côté des propriétaires."
 
 #. Tag: para
 #: Entity.xml:457
@@ -1884,12 +1992,14 @@
 "because the property name is <literal>passport</literal> and the column id "
 "of <literal>Passport </literal>is <literal>id</literal>."
 msgstr ""
+"Si aucune <literal>@JoinColumn</literal> n'est déclarée du côté du propriétaire, les valeurs par défaut s'appliquent. Une ou plusieurs colonnes de jointure seront créées dans la table du propriétaire et son nom sera constitué par l'enchaînement du nom de la relation du côté du propriétaire, <keycap>_</keycap> (trait de soulignement), et le nom de ou des colonne(s) du côté possédé. Dans cet exemple, <literal>passport_id</literal> "
+"car le nom de propriété est <literal>passport</literal> et que l'id de colonne de <literal>Passport </literal>est <literal>id</literal>."
 
 #. Tag: para
 #: Entity.xml:460
 #, no-c-format
 msgid "The third possibility (using an association table) is very exotic."
-msgstr ""
+msgstr "La troisième possibilité (en utilisant une table d'associations) est très exotique."
 
 #. Tag: programlisting
 #: Entity.xml:463
@@ -1914,6 +2024,24 @@
 "    ...\n"
 "}"
 msgstr ""
+"@Entity\n"
+"public class Customer implements Serializable {\n"
+"    @OneToOne(cascade = CascadeType.ALL)\n"
+"    <emphasis role=\"bold\">@JoinTable(name = \"CustomerPassports\" "
+"joinColumns = @JoinColumn(name=\"customer_fk\"),</emphasis>\n"
+"    <emphasis role=\"bold\">inverseJoinColumns = @JoinColumns(name="
+"\"passport_fk\")\n"
+"    )</emphasis>\n"
+"    public Passport getPassport() {\n"
+"        ...\n"
+"    }\n"
+"\n"
+"@Entity\n"
+"public class Passport implements Serializable {\n"
+"    @OneToOne(<emphasis role=\"bold\">mappedBy = \"passport\"</emphasis>)\n"
+"    public Customer getOwner() {\n"
+"    ...\n"
+"}"
 
 #. Tag: para
 #: Entity.xml:464
@@ -1928,6 +2056,12 @@
 "<literal>Customer</literal> table materialized by the <literal>joinColumns</"
 "literal> attribute."
 msgstr ""
+"Un <classname>Customer</classname> est lié à un <classname>Passport</"
+"classname> par une table d'association nommée <literal>CustomerPassports</"
+"literal> ; cette table d'association comporte une colonne de clés étrangères nommée "
+"<literal>passport_fk</literal> qui pointe vers la table <literal>Passport</literal> (materialisée par <literal>inverseJoinColumn</literal>, et une colonne de clés étrangères nommée <literal>customer_fk</literal> pointant vers la table "
+"<literal>Customer</literal> et matérialisée par l'attribut <literal>joinColumns</"
+"literal>."
 
 #. Tag: para
 #: Entity.xml:467
@@ -1935,13 +2069,13 @@
 msgid ""
 "You must declare the join table name and the join columns explicitly in such "
 "a mapping."
-msgstr ""
+msgstr "Vous devez déclarer le nom de la table de jointure et les colonnes de jointure explicitement dans un tel mappage."
 
 #. Tag: title
 #: Entity.xml:470
 #, no-c-format
 msgid "Many-to-one"
-msgstr ""
+msgstr "Many-to-one"
 
 #. Tag: para
 #: Entity.xml:471
@@ -1949,7 +2083,7 @@
 msgid ""
 "Many-to-one associations are declared at the property level with the "
 "annotation <literal>@ManyToOne</literal>:"
-msgstr ""
+msgstr "Les associations many-to-one sont déclarées au niveau propriété par l'annotation <literal>@ManyToOne</literal> :"
 
 #. Tag: programlisting
 #: Entity.xml:474
@@ -1966,6 +2100,16 @@
 "    ...\n"
 "}"
 msgstr ""
+"@Entity()\n"
+"public class Flight implements Serializable {\n"
+"    <emphasis role=\"bold\">@ManyToOne</emphasis>( cascade = {CascadeType."
+"PERSIST, CascadeType.MERGE} )\n"
+"    @JoinColumn(name=\"COMP_ID\")\n"
+"    public Company getCompany() {\n"
+"        return company;\n"
+"    }\n"
+"    ...\n"
+"}"
 
 #. Tag: para
 #: Entity.xml:475
@@ -1978,6 +2122,8 @@
 "literal> because the property name is <literal>company</literal> and the "
 "column id of Company is <literal>id</literal>."
 msgstr ""
+"L'attribut <literal>@JoinColumn</literal> est optionnel, la(les) valeur(s) par défaut sont comme dans one-to-one, la concaténation du nom de la relation du côté du propriétaire, <keycap>_</keycap> (trait de soulignement), et le nom de la colonne de clé primaire du côté possédé. Dans cet exemple, <literal>company_id</"
+"literal> car le nom de la propriété est <literal>company</literal> et l'id de la colonne de Company est <literal>id</literal>."
 
 #. Tag: para
 #: Entity.xml:478
@@ -1989,6 +2135,8 @@
 "the association) is good in almost all cases. However this is useful when "
 "you want to use interfaces as the return type instead of the regular entity."
 msgstr ""
+"<literal>@ManyToOne</literal> possède un paramètre mommé <literal>targetEntity</"
+"literal> qui décrit le nom de l'entité ciblée. Vous n'avez pas normalement besoin de ce paramètre car la valeur par défaut (le type de propriété qui stocke l'association) est bonne dans presque tous les cas. Malgré tout, c'est utile quand vous souhaitez utiliser les interfaces en tant que type de retour à la place des entités habituelles."
 
 #. Tag: programlisting
 #: Entity.xml:481
@@ -2008,6 +2156,19 @@
 "public interface Company {\n"
 "    ..."
 msgstr ""
+"@Entity()\n"
+"public class Flight implements Serializable {\n"
+"    @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, \n"
+"    <emphasis role=\"bold\">targetEntity=CompanyImpl.class</emphasis> )\n"
+"    @JoinColumn(name=\"COMP_ID\")\n"
+"    public Company getCompany() {\n"
+"        return company;\n"
+"    }\n"
+"    ...\n"
+"}\n"
+"\n"
+"public interface Company {\n"
+"    ..."
 
 #. Tag: para
 #: Entity.xml:482
@@ -2020,6 +2181,8 @@
 "referencing the target entity table (through <literal>@JoinTable."
 "inverseJoinColumns</literal>)."
 msgstr ""
+"Vous pouvez également mapper une association many-to-one par la table d'associations. Cette table d'associations décrite par l'annotation <literal>@JoinTable</literal> contiendra une clé étrangère référençant la table d'entités (par <literal>@JoinTable.joinColumns</literal>) et une clé étrangère référençant la table d'entité ciblée (par <literal>@JoinTable."
+"inverseJoinColumns</literal>)."
 
 #. Tag: programlisting
 #: Entity.xml:485
@@ -2038,18 +2201,30 @@
 "    ...\n"
 "}"
 msgstr ""
+"@Entity()\n"
+"public class Flight implements Serializable {\n"
+"    @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )\n"
+"    <emphasis role=\"bold\">@JoinTable(name=\"Flight_Company\", joinColumns "
+"= @JoinColumn(name=\"FLIGHT_ID\"),</emphasis>\n"
+"    <emphasis role=\"bold\">inverseJoinColumns = @JoinColumns(name=\"COMP_ID"
+"\") )</emphasis>\n"
+"    public Company getCompany() {\n"
+"        return company;\n"
+"    }\n"
+"    ...\n"
+"}"
 
 #. Tag: title
 #: Entity.xml:486
 #, no-c-format
 msgid "Collections"
-msgstr ""
+msgstr "Collections"
 
 #. Tag: title
 #: Entity.xml:487
 #, no-c-format
 msgid "Overview"
-msgstr ""
+msgstr "Aperçu général"
 
 #. Tag: para
 #: Entity.xml:488
@@ -2081,60 +2256,70 @@
 "<literal>@MapKey</literal> still has some limitations, please check the "
 "forum or the JIRA tracking system for more informations."
 msgstr ""
+"Vous pouvez mapper <classname>Collection</classname>, <literal>List</literal> (c'est à dire "
+"des listes ordonnées, non pas des listes indexées), <literal>Map</literal> et "
+"<classname>Set</classname>. La spécification EJB3 décrit comment mapper une liste ordonnée (c'est à dire une liste ordonnée en cours de chargement) en utilisant l'annotation <literal>@javax."
+"persistence.OrderBy</literal> : cette annotation prend pour paramétre une liste de propriétés séparées par des virgules (entités cibles) pour ordonner la collection (ex. code>firstname asc, age desc</code>), si la chaîne est vide, la collection sera ordonnée par id. <literal>@OrderBy</literal> "
+"ne fonctionne actuellement uniquement avec des collections qui n'ont pas de tables d'association. Pour les collections indexées true, veuillez vous reporter à <xref linkend=\"Entity_Beans-"
+"Hibernate_Annotation_Extensions\"/>. EJB3 vous permet de mapper Maps en utilisant pour clé, une des propriétés d'entité cible avec <literal>@MapKey(name="
+"\"myProperty\")</literal> (myProperty est un nom de propriété de l'entité cible). Quand on utilise <literal>@MapKey</literal> (sans nom de propriété), la clé primaire d'entité cible est utilisée. La clé de mappage utilise la même colonne que celle qui était indiquée par la propriété : il n'y a pas de colonne supplémentaire déterminée pour contenir la clé de mappage, et c'est logique, psuisque la clé de mappage représente en fait uen propriété cible. Sachez qu'une fois qu'elle est téléchargée, la clé n'est plus en sync avec la propriété, c'est à dire que si vous changez la valeur de la propriété, la clé ne sera pas changée automatiquement dans votre modèle Java (pour un véritable support de mappage, veuillez vous référer à <xref linkend=\"Entity_Beans-Hibernate_Annotation_Extensions\"/>). "
+"De nombreuses personns confondent les possibilités de <literal>&lt;map&gt;</literal> avec celles de "
+"<literal>@MapKey</literal>. Ce sont des fonctionnalités bien distinctes."
+"<literal>@MapKey</literal> comporte encore quelques limitations, veuillez consulter le forum ou bien le système de traçage JIRA pour davantage d'informations."
 
 #. Tag: para
 #: Entity.xml:491
 #, no-c-format
 msgid "Hibernate has several notions of collections."
-msgstr ""
+msgstr "Hibernate possède plusieurs notions de collections."
 
 #. Tag: title
 #: Entity.xml:495
 #, no-c-format
 msgid "Collections semantics"
-msgstr ""
+msgstr "Semantiques de collections"
 
 #. Tag: entry
 #: Entity.xml:502
 #, no-c-format
 msgid "Semantic"
-msgstr ""
+msgstr "Sémantiques"
 
 #. Tag: entry
 #: Entity.xml:505
 #, no-c-format
 msgid "java representation"
-msgstr ""
+msgstr "représentation java"
 
 #. Tag: entry
 #: Entity.xml:508
 #, no-c-format
 msgid "annotations"
-msgstr ""
+msgstr "annotations"
 
 #. Tag: entry
 #: Entity.xml:515
 #, no-c-format
 msgid "Bag semantic"
-msgstr ""
+msgstr "Bag semantic"
 
 #. Tag: entry
 #: Entity.xml:518 Entity.xml:529
 #, no-c-format
 msgid "java.util.List, java.util.Collection"
-msgstr ""
+msgstr "java.util.List, java.util.Collection"
 
 #. Tag: entry
 #: Entity.xml:521 Entity.xml:554
 #, no-c-format
 msgid "@org.hibernate.annotations.CollectionOfElements or @OneToMany or @ManyToMany"
-msgstr ""
+msgstr "@org.hibernate.annotations.CollectionOfElements or @OneToMany or @ManyToMany"
 
 #. Tag: entry
 #: Entity.xml:526
 #, no-c-format
 msgid "Bag semantic with primary key (withtout the limitations of Bag semantic)"
-msgstr ""
+msgstr "Bag semantic avec la clé primaire (sans les limitaitons de Bag semantic)"
 
 #. Tag: entry
 #: Entity.xml:532
@@ -2143,18 +2328,20 @@
 "(@org.hibernate.annotations.CollectionOfElements or @OneToMany or "
 "@ManyToMany) and @CollectionId"
 msgstr ""
+"(@org.hibernate.annotations.CollectionOfElements or @OneToMany or "
+"@ManyToMany) and @CollectionId"
 
 #. Tag: entry
 #: Entity.xml:537
 #, no-c-format
 msgid "List semantic"
-msgstr ""
+msgstr "List semantic"
 
 #. Tag: entry
 #: Entity.xml:540
 #, no-c-format
 msgid "java.util.List"
-msgstr ""
+msgstr "java.util.List"
 
 #. Tag: entry
 #: Entity.xml:543
@@ -2163,30 +2350,32 @@
 "(@org.hibernate.annotations.CollectionOfElements or @OneToMany or "
 "@ManyToMany) and @org.hibernate.annotations.IndexColumn"
 msgstr ""
+"(@org.hibernate.annotations.CollectionOfElements or @OneToMany or "
+"@ManyToMany) et @org.hibernate.annotations.IndexColumn"
 
 #. Tag: entry
 #: Entity.xml:548
 #, no-c-format
 msgid "Set semantic"
-msgstr ""
+msgstr "Set semantic"
 
 #. Tag: entry
 #: Entity.xml:551
 #, no-c-format
 msgid "java.util.Set"
-msgstr ""
+msgstr "java.util.Set"
 
 #. Tag: entry
 #: Entity.xml:559
 #, no-c-format
 msgid "Map semantic"
-msgstr ""
+msgstr "Map semantic"
 
 #. Tag: entry
 #: Entity.xml:562
 #, no-c-format
 msgid "java.util.Map"
-msgstr ""
+msgstr "java.util.Map"
 
 #. Tag: entry
 #: Entity.xml:565
@@ -2196,6 +2385,9 @@
 "@ManyToMany) and (nothing or @org.hibernate.annotations.MapKey/"
 "MapKeyManyToMany for true map support, OR @javax.persistence.MapKey"
 msgstr ""
+"(@org.hibernate.annotations.CollectionOfElements or @OneToMany or "
+"@ManyToMany) et (nothing or @org.hibernate.annotations.MapKey/"
+"MapKeyManyToMany pour support de mappage true, OU @javax.persistence.MapKey"
 
 #. Tag: remark
 #: Entity.xml:572
@@ -2204,6 +2396,8 @@
 "So specifically, java.util.List collections without @org.hibernate."
 "annotations.IndexColumn are going to be considered as bags."
 msgstr ""
+"Donc plus spécifiquement, les collections java.util.List sans @org.hibernate."
+"annotations.IndexColumn seront considérés en tant que bags."
 
 #. Tag: para
 #: Entity.xml:573
@@ -2213,6 +2407,8 @@
 "the EJB3 specification. Hibernate Annotations allows them however (see <xref "
 "linkend=\"Entity_Beans-Hibernate_Annotation_Extensions\"/>)."
 msgstr ""
+"La collection d'objets primitifs, type core ou imbriqués n'est pas prise en charge par la spécification EJB3. Hibernate Annotations les autorise malgé tout (voir <xref "
+"linkend=\"Entity_Beans-Hibernate_Annotation_Extensions\"/>)."
 
 #. Tag: programlisting
 #: Entity.xml:576
@@ -2260,6 +2456,47 @@
 "...\n"
 "}"
 msgstr ""
+"@Entity public class City {\n"
+"    @OneToMany(mappedBy=\"city\")\n"
+"    <emphasis role=\"bold\">@OrderBy(\"streetName\")</emphasis>\n"
+"    public List&lt;Street&gt; getStreets() {\n"
+"        return streets;\n"
+"    }\n"
+"...\n"
+"}\n"
+"\n"
+"@Entity public class Street {\n"
+"    <emphasis role=\"bold\">public String getStreetName()</emphasis> {\n"
+"        return streetName;\n"
+"    }\n"
+"\n"
+"    @ManyToOne\n"
+"    public City getCity() {\n"
+"        return city;\n"
+"    }\n"
+"    ...\n"
+"}\n"
+"\n"
+"\n"
+"@Entity\n"
+"public class Software {\n"
+"    @OneToMany(mappedBy=\"software\")\n"
+"    <emphasis role=\"bold\">@MapKey(name=\"codeName\")</emphasis>\n"
+"    public Map&lt;String, Version&gt; getVersions() {\n"
+"        return versions;\n"
+"    }\n"
+"...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"@Table(name=\"tbl_version\")\n"
+"public class Version {\n"
+"    <emphasis role=\"bold\">public String getCodeName()</emphasis> {...}\n"
+"\n"
+"    @ManyToOne\n"
+"    public Software getSoftware() { ... }\n"
+"...\n"
+"}"
 
 #. Tag: para
 #: Entity.xml:577
@@ -2271,6 +2508,10 @@
 "map of <literal>Version</literal>s which key is the <literal>Version</"
 "literal><literal>codeName</literal>."
 msgstr ""
+"Donc <literal>City</literal> (Ville) possède une collection de <literal>Street</literal> (rue)s "
+"qui sont ordonnées par <literal>streetName</literal> (noms de rue) (de <literal>Street</"
+"literal> (Rue)) quand la collection est chargée. <literal>Software</literal> possède une mappe de <literal>Version</literal>s dont la clé est le <literal>codeName</literal>(nom de code) de la <literal>Version</"
+"literal>."
 
 #. Tag: para
 #: Entity.xml:580
@@ -2279,13 +2520,13 @@
 "Unless the collection is a generic, you will have to define "
 "<literal>targetEntity</literal>. This is a annotation attribute that take "
 "the target entity class as a value."
-msgstr ""
+msgstr "A moins que la collection soit générique, vous devrez déterminer <literal>targetEntity</literal>. Il s'agit d'un attribut d'annotation qui prend la classe de l'entité cible comme valeur."
 
 #. Tag: title
 #: Entity.xml:583
 #, no-c-format
 msgid "One-to-many"
-msgstr ""
+msgstr "One-to-many"
 
 #. Tag: para
 #: Entity.xml:584
@@ -2294,7 +2535,7 @@
 "One-to-many associations are declared at the property level with the "
 "annotation <literal>@OneToMany</literal>. One to many associations may be "
 "bidirectional."
-msgstr ""
+msgstr "Les associations one-to-many sont déclarées au niveau de la propriété par l'annotation <literal>@OneToMany</literal>. Les associations one-to-may peuvent être bidirectionnelles."
 
 #. Tag: sect4
 #: Entity.xml:586
@@ -2422,12 +2663,108 @@
 "literal> to <literal>Monkey</literal> (property name, <keycap>_</keycap>, "
 "Tiger primary column). </para> </sect5>"
 msgstr ""
+"<sect5 id=\"One_to_many-Bidirectional\"><title>Bidirectionel</title> <para> "
+"Comme la plupart des many to one sont (presque) toujours le côté propriétaire d'une relation bidirectionnelle dans la spec EJB3, l'association many-to-one est annotée avec "
+"<literal>@OneToMany( mappedBy=... )</literal> </para> "
+"<programlisting>@Entity\n"
+"public class Troop {\n"
+"    @OneToMany(mappedBy=\"troop\")\n"
+"    public Set&lt;Soldier&gt; getSoldiers() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Soldier {\n"
+"    @ManyToOne\n"
+"    @JoinColumn(name=\"troop_fk\")\n"
+"    public Troop getTroop() {\n"
+"    ...\n"
+"}              \n"
+"</programlisting> <para> <classname>Troop</classname> aune relation one to many bidirectionnelle avec <literal>Soldier</literal> par la propriété "
+"<literal>troop</literal>. Vous n'avez pas (dutout) besoin de déterminer un mappage physique du côté <literal>mappedBy</literal>. </para> <para> "
+"Pour mapper un bidirectionnel one to many, avec le côté one-to-many en tant que côté possédant, vous devez retirer l'élément <literal>mappedBy</literal> et paramétrer le "
+"many to one <literal>@JoinColumn</literal> comme insérable et pouvant être mis à jour à "
+"false. Cette solution n'est franchement pas optimisée et produira quelques ennoncés UPDATE supplémentaires. </para> <programlisting>@Entity\n"
+"public class Troop {\n"
+"    @OneToMany\n"
+"    @JoinColumn(name=\"troop_fk\") //we need to duplicate the physical "
+"information\n"
+"    public Set&lt;Soldier&gt; getSoldiers() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Soldier {\n"
+"    @ManyToOne\n"
+"    @JoinColumn(name=\"troop_fk\", insertable=false, updatable=false)\n"
+"    public Troop getTroop() {\n"
+"    ...\n"
+"}\n"
+"</programlisting> </sect5><sect5 id=\"One_to_many-Unidirectional"
+"\"><title>Unidirectional</title> <para> Un unidirectionnel one to many qui utilise une colonne de clés étrangères dans l'entité possédée n'est pas si commun et pas vraiment recommandé. Nous vous conseillons fortement d'utiliser une table de jointure pour ce genre d'associations (comme expliqué dans la prochaine section). Ce genre d'association est décrit dans un <literal>@JoinColumn</literal> </para> <programlisting>\n"
+"@Entity\n"
+"public class Customer implements Serializable {\n"
+"    @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)\n"
+"    @JoinColumn(name=\"CUST_ID\")\n"
+"    public Set&lt;Ticket&gt; getTickets() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Ticket implements Serializable {\n"
+"    ... //no bidir\n"
+"}\n"
+"               \n"
+"</programlisting> <para> <literal>Customer</literal> décrit une relation unidirectionnelle avec <literal>Ticket</literal> en utilisant la colonne de jointure <literal>CUST_ID</literal>. </para> </sect5><sect5 id=\"One_to_many-"
+"Unidirectional_with_join_table\"><title>Unidirectionne avec table de jointure</"
+"title> <para> Une unidirectionnel one to many avec table de jointure est bien plus souhaitable. Cette association est décrite dans <literal>@JoinTable</"
+"literal>. </para> <programlisting>\n"
+"@Entity\n"
+"public class Trainer {\n"
+"    @OneToMany\n"
+"    @JoinTable(\n"
+"            name=\"TrainedMonkeys\",\n"
+"            joinColumns = { @JoinColumn( name=\"trainer_id\") },\n"
+"            inverseJoinColumns = @JoinColumn( name=\"monkey_id\")\n"
+"    )\n"
+"    public Set&lt;Monkey&gt; getTrainedMonkeys() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Monkey {\n"
+"    ... //no bidir\n"
+"}\n"
+"               \n"
+"</programlisting> <para> <literal>Trainer</literal> décrit une relation unidirectionnelle avec <classname>Monkey</classname> en utilisant la table de jointure <classname>TrainedMonkeys</classname>, avec une clé étrangère <literal>trainer_id</literal> pour <literal>Trainer</literal> "
+"(<literal>joinColumns</literal>) et une clé étrangère <literal>monkey_id</"
+"literal> pour <literal>Monkey</literal> (<literal>inversejoinColumns</"
+"literal>). </para> </sect5><sect5 id=\"One_to_many-Defaults\" revision=\"1"
+"\"><title>Defaults</title> <para> Si on ne décrit pas de mappage physique, un unidirectionnel one-to-many avec table de jointure est utilisé. Le nom de la table est la concaténation du nom de la table de propriétaire, <keycap>_</keycap>, associé au nom de ou des colonnes de clés primaires de l'autre partie. Il y a une contrainte qui se rajoute à la clé étrangère qui référence la table de l'autre partie pour refléter le one-to-many. </"
+"para> <programlisting>\n"
+"@Entity\n"
+"public class Trainer {\n"
+"    @OneToMany\n"
+"    public Set&lt;Tiger&gt; getTrainedTigers() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Tiger {\n"
+"    ... //no bidir\n"
+"}\n"
+"               \n"
+"</programlisting> <para> <classname>Trainer</classname> décrit une relation unidirectionnelle avec <classname>Tiger</classname> utilisant la table de jointure <literal>Trainer_Tiger</literal>, avec une clé étrangère "
+"<literal>trainer_id</literal> pour <literal>Trainer</literal> (table name, "
+"<keycap>_</keycap>, trainer id) et une clé étrangère <literal>trainedTigers_id</"
+"literal> pour <literal>Monkey</literal> (property name, <keycap>_</keycap>, "
+"Tiger primary column). </para> </sect5>"
 
 #. Tag: title
 #: Entity.xml:623
 #, no-c-format
 msgid "Many-to-many"
-msgstr ""
+msgstr "Many-to-many"
 
 #. Tag: sect4
 #: Entity.xml:623
@@ -2539,6 +2876,98 @@
 "<literal>Store</literal> table. The <literal>customers_id</literal> column "
 "is a foreign key to the <literal>Customer</literal> table. </para> </sect5>"
 msgstr ""
+"<sect5 id=\"Many_to_many-Definition\"><title>Definition</title> <para> Une association "
+"many-to-many est définie logiquement en utilisant l'association "
+"<literal>@ManyToMany</literal>. Vous avez également besoin de décrire la table d'association et les condition de jointure en utilisant l'annotation <literal>@JoinTable</"
+"literal>. Si l'association est bidirectionnelle, une des parties sera le propriétaire et l'autre l'inverse (c'est à dire qu'il sera ignoré quand on mettra à jour les valeurs de la relation dans la table d'associations) :</para> "
+"<programlisting>\n"
+"@Entity\n"
+"public class Employer implements Serializable {\n"
+"    @ManyToMany(\n"
+"        targetEntity=org.hibernate.test.metadata.manytomany.Employee.class,\n"
+"        cascade={CascadeType.PERSIST, CascadeType.MERGE}\n"
+"    )\n"
+"    @JoinTable(\n"
+"        name=\"EMPLOYER_EMPLOYEE\",\n"
+"        joinColumns={@JoinColumn(name=\"EMPER_ID\")},\n"
+"        inverseJoinColumns={@JoinColumn(name=\"EMPEE_ID\")}\n"
+"    )\n"
+"    public Collection getEmployees() {\n"
+"        return employees;\n"
+"    }\n"
+"    ...\n"
+"}\n"
+"               \n"
+"</programlisting> <programlisting>\n"
+"@Entity\n"
+"public class Employee implements Serializable {\n"
+"    @ManyToMany(\n"
+"        cascade={CascadeType.PERSIST, CascadeType.MERGE},\n"
+"        mappedBy=\"employees\"\n"
+"        targetEntity=Employer.class\n"
+"    )\n"
+"    public Collection getEmployers() {\n"
+"        return employers;\n"
+"    }\n"
+"}\n"
+"               \n"
+"</programlisting> <para> Nous avons déjà montré les nombreuses déclarations et les attributs en détails des associations. Nous allons aller plus loin dans la description "
+"<literal>@JoinTable</literal>. Elle détermine un <literal>name</"
+"literal>, un tableau de colonnes jointes (un tableau d'annotations est défini en utilisant { A, B, C }), et un tableau de colonnes jointes en sens inverse. Ces dernières sont les colonnes de la table d'associations qui se rapporte à la clé primaire d'<classname>Employee</"
+"classname> (l\" \"autre partie\"). </para> <para> Comme nous l'avons vu précédemment, l'autre partie de doit (surtout) pas décrire le mappage physique : un argument simple <literal>mappedBy</literal> qui contient le nom de propriété du côté propriétaire relie les deux. </para> </sect5><sect5 id="
+"\"Many_to_many-Default_values\"><title>Default values</title> <para> Tout comme n'importe quelle annotation, la plupart des valeurs sont devinées dans une relation many-to-many. Sans décrire un mappage physique dans un unidirectionnel many-to-many, les règles suivantes s'appliquent. Le nom de la table est la concaténation du nom de la table du propriétaire, <keycap>_</keycap> et le nom du tableau de l'autre partie. Les noms de clés étrangères référençant la table du propriétaire est la concaténation du nom de la table du propriétaire, <keycap>_</keycap> et le ou les colonne(s) de la clé primaire du propriétaire, le ou les nom(s) "
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+"and the owner primary key column(s). The "
+"foreign key name(s) referencing the other side is the concatenation of the "
+"owner property name, <keycap>_</keycap>, and the other side primary key "
+"column(s). These are the same rules used for a unidirectional one to many "
+"relationship. </para> <programlisting>\n"
+"@Entity\n"
+"public class Store {\n"
+"    @ManyToMany(cascade = CascadeType.PERSIST)\n"
+"    public Set&lt;City&gt; getImplantedIn() {\n"
+"        ...\n"
+"    }\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class City {\n"
+"    ... //no bidirectional relationship\n"
+"}\n"
+"               \n"
+"</programlisting> <para> Un <literal>Store_City</literal> is used as the join "
+"table. The <literal>Store_id</literal> column is a foreign key to the "
+"<literal>Store</literal> table. The <literal>implantedIn_id</literal> column "
+"is a foreign key to the <literal>City</literal> table. </para> <para> "
+"Without describing any physical mapping in a bidirectional many to many the "
+"following rules applied. The table name is the concatenation of the owner "
+"table name, <keycap>_</keycap> and the other side table name. The foreign "
+"key name(s) referencing the owner table is the concatenation of the other "
+"side property name, <keycap>_</keycap>, and the owner primary key column(s). "
+"The foreign key name(s) referencing the other side is the concatenation of "
+"the owner property name, <keycap>_</keycap>, and the other side primary key "
+"column(s). These are the same rules used for a unidirectional one to many "
+"relationship. </para> <programlisting>\n"
+"@Entity\n"
+"public class Store {\n"
+"    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})\n"
+"    public Set&lt;Customer&gt; getCustomers() {\n"
+"        ...\n"
+"    }\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Customer {\n"
+"    @ManyToMany(mappedBy=\"customers\")\n"
+"    public Set&lt;Store&gt; getStores() {\n"
+"        ...\n"
+"    }\n"
+"}\n"
+"               \n"
+"</programlisting> <para> A <literal>Store_Customer</literal> is used as the "
+"join table. The <literal>stores_id</literal> column is a foreign key to the "
+"<literal>Store</literal> table. The <literal>customers_id</literal> column "
+"is a foreign key to the <literal>Customer</literal> table. </para> </sect5>"
 
 #. Tag: title
 #: Entity.xml:651